// Copyright 2020, Chef.  All rights reserved.
// https://github.com/q191201771/lal
//
// Use of this source code is governed by a MIT-style license
// that can be found in the License file.
//
// Author: Chef (191201771@qq.com)

package rtsp

import (
	"bufio"
	"net"
	"strings"

	"github.com/q191201771/naza/pkg/connection"

	"github.com/q191201771/lal/pkg/base"
	"github.com/q191201771/lal/pkg/sdp"
	"github.com/q191201771/naza/pkg/nazahttp"
	"github.com/q191201771/naza/pkg/nazalog"
)

type ServerCommandSessionObserver interface {
	// @brief  Announce阶段回调
	// @return 如果返回false，则表示上层要强制关闭这个推流请求
	OnNewRTSPPubSession(session *PubSession) bool

	// @brief Describe阶段回调
	// @return ok  如果返回false，则表示上层要强制关闭这个拉流请求
	// @return sdp
	OnNewRTSPSubSessionDescribe(session *SubSession) (ok bool, sdp []byte)

	// @brief Describe阶段回调
	// @return ok  如果返回false，则表示上层要强制关闭这个拉流请求
	OnNewRTSPSubSessionPlay(session *SubSession) bool
}

type ServerCommandSession struct {
	UniqueKey    string                       // const after ctor
	observer     ServerCommandSessionObserver // const after ctor
	conn         connection.Connection
	prevConnStat connection.Stat
	staleStat    *connection.Stat
	stat         base.StatSession

	pubSession *PubSession
	subSession *SubSession
}

func NewServerCommandSession(observer ServerCommandSessionObserver, conn net.Conn) *ServerCommandSession {
	uk := base.GenUniqueKey(base.UKPRTSPServerCommandSession)
	s := &ServerCommandSession{
		UniqueKey: uk,
		observer:  observer,
		conn: connection.New(conn, func(option *connection.Option) {
			option.ReadBufSize = serverCommandSessionReadBufSize
		}),
	}

	nazalog.Infof("[%s] lifecycle new rtmp ServerSession. session=%p, remote addr=%s", uk, s, conn.RemoteAddr().String())
	return s
}

func (s *ServerCommandSession) RunLoop() error {
	return s.runCmdLoop()
}

func (s *ServerCommandSession) Dispose() error {
	return s.conn.Close()
}

func (s *ServerCommandSession) UpdateStat(interval uint32) {
	currStat := s.conn.GetStat()
	rDiff := currStat.ReadBytesSum - s.prevConnStat.ReadBytesSum
	s.stat.Bitrate = int(rDiff * 8 / 1024 / uint64(interval))
	wDiff := currStat.WroteBytesSum - s.prevConnStat.WroteBytesSum
	s.stat.Bitrate = int(wDiff * 8 / 1024 / uint64(interval))
	s.prevConnStat = currStat
}

func (s *ServerCommandSession) GetStat() base.StatSession {
	connStat := s.conn.GetStat()
	s.stat.ReadBytesSum = connStat.ReadBytesSum
	s.stat.WroteBytesSum = connStat.WroteBytesSum
	return s.stat
}

func (s *ServerCommandSession) IsAlive() (readAlive, writeAlive bool) {
	currStat := s.conn.GetStat()
	if s.staleStat == nil {
		s.staleStat = new(connection.Stat)
		*s.staleStat = currStat
		return true, true
	}

	readAlive = !(currStat.ReadBytesSum-s.staleStat.ReadBytesSum == 0)
	writeAlive = !(currStat.WroteBytesSum-s.staleStat.WroteBytesSum == 0)
	*s.staleStat = currStat
	return
}

// 使用RTSP TCP命令连接，向对端发送RTP数据
func (s *ServerCommandSession) Write(channel int, b []byte) error {
	_, err := s.conn.Write(packInterleaved(channel, b))
	return err
}

func (s *ServerCommandSession) runCmdLoop() error {
	var r = bufio.NewReader(s.conn)

Loop:
	for {
		isInterleaved, packet, channel, err := readInterleaved(r)
		if err != nil {
			nazalog.Errorf("[%s] read interleaved error. err=%+v", s.UniqueKey, err)
			break Loop
		}
		if isInterleaved {
			// TODO chef: 考虑subSession的情况
			if s.pubSession == nil {
				nazalog.Errorf("[%s] read interleaved packet but pubSession not exist.", s.UniqueKey)
				break Loop
			}
			s.pubSession.HandleInterleavedPacket(packet, int(channel))
			continue
		}

		// 读取一个message
		requestCtx, err := nazahttp.ReadHTTPRequestMessage(r)
		if err != nil {
			nazalog.Errorf("[%s] read rtsp message error. err=%+v", s.UniqueKey, err)
			break Loop
		}

		nazalog.Debugf("[%s] read http request. method=%s, uri=%s, headers=%+v, body=%s", s.UniqueKey, requestCtx.Method, requestCtx.URI, requestCtx.Headers, string(requestCtx.Body))

		var handleMsgErr error
		switch requestCtx.Method {
		case MethodOptions:
			// pub, sub
			handleMsgErr = s.handleOptions(requestCtx)
		case MethodAnnounce:
			// pub
			handleMsgErr = s.handleAnnounce(requestCtx)
		case MethodDescribe:
			// sub
			handleMsgErr = s.handleDescribe(requestCtx)
		case MethodSetup:
			// pub, sub
			handleMsgErr = s.handleSetup(requestCtx)
		case MethodRecord:
			// pub
			handleMsgErr = s.handleRecord(requestCtx)
		case MethodPlay:
			// sub
			handleMsgErr = s.handlePlay(requestCtx)
		case MethodTeardown:
			// pub
			handleMsgErr = s.handleTeardown(requestCtx)
			break Loop
		default:
			nazalog.Errorf("[%s] unknown rtsp message. method=%s", s.UniqueKey, requestCtx.Method)
		}
		if handleMsgErr != nil {
			nazalog.Errorf("[%s] handle rtsp message error. err=%+v", s.UniqueKey, handleMsgErr)
			break
		}
	}

	_ = s.conn.Close()
	nazalog.Debugf("[%s] < handleTCPConnect.", s.UniqueKey)

	return nil
}

func (s *ServerCommandSession) handleOptions(requestCtx nazahttp.HTTPReqMsgCtx) error {
	nazalog.Infof("[%s] < R OPTIONS", s.UniqueKey)
	resp := PackResponseOptions(requestCtx.Headers[HeaderFieldCSeq])
	_, err := s.conn.Write([]byte(resp))
	return err
}

func (s *ServerCommandSession) handleAnnounce(requestCtx nazahttp.HTTPReqMsgCtx) error {
	nazalog.Infof("[%s] < R ANNOUNCE", s.UniqueKey)

	urlCtx, err := base.ParseRTSPURL(requestCtx.URI)
	if err != nil {
		nazalog.Errorf("[%s] parse presentation failed. uri=%s", s.UniqueKey, requestCtx.URI)
		return err
	}

	sdpLogicCtx, err := sdp.ParseSDP2LogicContext(requestCtx.Body)
	if err != nil {
		nazalog.Errorf("[%s] parse sdp failed. err=%v", s.UniqueKey, err)
		return err
	}

	s.pubSession = NewPubSession(urlCtx, s)
	nazalog.Infof("[%s] link new PubSession. [%s]", s.UniqueKey, s.pubSession.UniqueKey)
	s.pubSession.InitWithSDP(requestCtx.Body, sdpLogicCtx)

	if ok := s.observer.OnNewRTSPPubSession(s.pubSession); !ok {
		nazalog.Warnf("[%s] force close pubsession.", s.pubSession.UniqueKey)
		return ErrRTSP
	}

	resp := PackResponseAnnounce(requestCtx.Headers[HeaderFieldCSeq])
	_, err = s.conn.Write([]byte(resp))
	return err
}

func (s *ServerCommandSession) handleDescribe(requestCtx nazahttp.HTTPReqMsgCtx) error {
	nazalog.Infof("[%s] < R DESCRIBE", s.UniqueKey)

	urlCtx, err := base.ParseRTSPURL(requestCtx.URI)
	if err != nil {
		nazalog.Errorf("[%s] parse presentation failed. uri=%s", s.UniqueKey, requestCtx.URI)
		return err
	}

	s.subSession = NewSubSession(urlCtx, s)
	nazalog.Infof("[%s] link new SubSession. [%s]", s.UniqueKey, s.subSession.UniqueKey)
	ok, rawSDP := s.observer.OnNewRTSPSubSessionDescribe(s.subSession)
	if !ok {
		nazalog.Warnf("[%s] force close subSession.", s.UniqueKey)
		return ErrRTSP
	}

	ctx, _ := sdp.ParseSDP2LogicContext(rawSDP)
	s.subSession.InitWithSDP(rawSDP, ctx)

	resp := PackResponseDescribe(requestCtx.Headers[HeaderFieldCSeq], string(rawSDP))
	_, err = s.conn.Write([]byte(resp))
	return err
}

// 一次SETUP对应一路流（音频或视频）
func (s *ServerCommandSession) handleSetup(requestCtx nazahttp.HTTPReqMsgCtx) error {
	nazalog.Infof("[%s] < R SETUP", s.UniqueKey)

	remoteAddr := s.conn.RemoteAddr().String()
	host, _, _ := net.SplitHostPort(remoteAddr)

	// 是否为interleaved模式
	ts := requestCtx.Headers[HeaderFieldTransport]
	if strings.Contains(ts, TransportFieldInterleaved) {
		rtpChannel, rtcpChannel, err := parseRTPRTCPChannel(ts)
		if err != nil {
			nazalog.Errorf("[%s] parse rtp rtcp channel error. err=%+v", s.UniqueKey, err)
			return err
		}
		if s.pubSession != nil {
			if err := s.pubSession.SetupWithChannel(requestCtx.URI, int(rtpChannel), int(rtcpChannel), remoteAddr); err != nil {
				nazalog.Errorf("[%s] setup channel error. err=%+v", s.UniqueKey, err)
				return err
			}
		} else if s.subSession != nil {
			if err := s.subSession.SetupWithChannel(requestCtx.URI, int(rtpChannel), int(rtcpChannel), remoteAddr); err != nil {
				nazalog.Errorf("[%s] setup channel error. err=%+v", s.UniqueKey, err)
				return err
			}
		} else {
			nazalog.Errorf("[%s] setup but session not exist.", s.UniqueKey)
			return ErrRTSP
		}

		resp := PackResponseSetupTCP(requestCtx.Headers[HeaderFieldCSeq], ts)
		_, err = s.conn.Write([]byte(resp))
		return err
	}

	rRTPPort, rRTCPPort, err := parseClientPort(requestCtx.Headers[HeaderFieldTransport])
	if err != nil {
		nazalog.Errorf("[%s] parseClientPort failed. err=%+v", s.UniqueKey, err)
		return err
	}
	rtpConn, rtcpConn, lRTPPort, lRTCPPort, err := initConnWithClientPort(host, rRTPPort, rRTCPPort)
	if err != nil {
		nazalog.Errorf("[%s] initConnWithClientPort failed. err=%+v", s.UniqueKey, err)
		return err
	}

	if s.pubSession != nil {
		if err = s.pubSession.SetupWithConn(requestCtx.URI, rtpConn, rtcpConn); err != nil {
			nazalog.Errorf("[%s] setup conn error. err=%+v", s.UniqueKey, err)
			return err
		}
	} else if s.subSession != nil {
		if err = s.subSession.SetupWithConn(requestCtx.URI, rtpConn, rtcpConn); err != nil {
			nazalog.Errorf("[%s] setup conn error. err=%+v", s.UniqueKey, err)
			return err
		}
	} else {
		nazalog.Errorf("[%s] setup but session not exist.", s.UniqueKey)
		return ErrRTSP
	}

	resp := PackResponseSetup(requestCtx.Headers[HeaderFieldCSeq], rRTPPort, rRTCPPort, lRTPPort, lRTCPPort)
	_, err = s.conn.Write([]byte(resp))
	return err
}

func (s *ServerCommandSession) handleRecord(requestCtx nazahttp.HTTPReqMsgCtx) error {
	nazalog.Infof("[%s] < R RECORD", s.UniqueKey)
	resp := PackResponseRecord(requestCtx.Headers[HeaderFieldCSeq])
	_, err := s.conn.Write([]byte(resp))
	return err
}

func (s *ServerCommandSession) handlePlay(requestCtx nazahttp.HTTPReqMsgCtx) error {
	nazalog.Infof("[%s] < R PLAY", s.UniqueKey)
	if ok := s.observer.OnNewRTSPSubSessionPlay(s.subSession); !ok {
		return ErrRTSP
	}
	resp := PackResponsePlay(requestCtx.Headers[HeaderFieldCSeq])
	_, err := s.conn.Write([]byte(resp))
	return err
}

func (s *ServerCommandSession) handleTeardown(requestCtx nazahttp.HTTPReqMsgCtx) error {
	nazalog.Infof("[%s] < R TEARDOWN", s.UniqueKey)
	resp := PackResponseTeardown(requestCtx.Headers[HeaderFieldCSeq])
	_, err := s.conn.Write([]byte(resp))
	return err
}