package rtsp

import (
	"bufio"
	"encoding/binary"
	"errors"
	"fmt"
	"net"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"

	"github.com/AlexxIT/go2rtc/pkg/tcp/websocket"

	"github.com/AlexxIT/go2rtc/pkg/core"
	"github.com/AlexxIT/go2rtc/pkg/tcp"
)

var Timeout = time.Second * 5

func NewClient(uri string) *Conn {
	return &Conn{
		Connection: core.Connection{
			ID:         core.NewID(),
			FormatName: "rtsp",
		},
		uri:              uri,
		udpRtpConns:      make(map[byte]*UDPConnection),
		udpRtcpConns:     make(map[byte]*UDPConnection),
		udpRtpListeners:  make(map[byte]*UDPConnection),
		udpRtcpListeners: make(map[byte]*UDPConnection),
		portToChannel:    make(map[int]byte),
		channelCounter:   0,
	}
}

func (c *Conn) Dial() (err error) {
	if c.URL, err = url.Parse(c.uri); err != nil {
		return
	}

	var conn net.Conn

	if c.Transport == "" || c.Transport == "tcp" || c.Transport == "udp" {
		timeout := core.ConnDialTimeout
		if c.Timeout != 0 {
			timeout = time.Second * time.Duration(c.Timeout)
		}
		conn, err = tcp.Dial(c.URL, timeout)

		if c.Transport != "udp" {
			c.Protocol = "rtsp+tcp"
		} else {
			c.Protocol = "rtsp+udp"
		}
	} else {
		conn, err = websocket.Dial(c.Transport)
		c.Protocol = "ws"
	}
	if err != nil {
		return
	}

	// remove UserInfo from URL
	c.auth = tcp.NewAuth(c.URL.User)
	c.URL.User = nil

	c.conn = conn
	c.reader = bufio.NewReaderSize(conn, core.BufferSize)
	c.session = ""
	c.sequence = 0
	c.state = StateConn

	c.Connection.RemoteAddr = conn.RemoteAddr().String()
	c.Connection.Transport = conn
	c.Connection.URL = c.uri

	return nil
}

// Do send WriteRequest and receive and process WriteResponse
func (c *Conn) Do(req *tcp.Request) (*tcp.Response, error) {
	if err := c.WriteRequest(req); err != nil {
		return nil, err
	}

	res, err := c.ReadResponse()
	if err != nil {
		return nil, err
	}

	c.Fire(res)

	if res.StatusCode == http.StatusUnauthorized {
		switch c.auth.Method {
		case tcp.AuthNone:
			if c.auth.ReadNone(res) {
				return c.Do(req)
			}
			return nil, errors.New("user/pass not provided")
		case tcp.AuthUnknown:
			if c.auth.Read(res) {
				return c.Do(req)
			}
		default:
			return nil, errors.New("wrong user/pass")
		}
	}

	if res.StatusCode != http.StatusOK {
		return res, fmt.Errorf("wrong response on %s", req.Method)
	}

	return res, nil
}

func (c *Conn) Options() error {
	req := &tcp.Request{Method: MethodOptions, URL: c.URL}

	res, err := c.Do(req)
	if err != nil {
		return err
	}

	if val := res.Header.Get("Content-Base"); val != "" {
		c.URL, err = urlParse(val)
		if err != nil {
			return err
		}
	}

	return nil
}

func (c *Conn) Describe() error {
	// 5.3 Back channel connection
	// https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec.pdf
	req := &tcp.Request{
		Method: MethodDescribe,
		URL:    c.URL,
		Header: map[string][]string{
			"Accept": {"application/sdp"},
		},
	}

	if c.Backchannel {
		req.Header.Set("Require", "www.onvif.org/ver20/backchannel")
	}

	if c.UserAgent != "" {
		// this camera will answer with 401 on DESCRIBE without User-Agent
		// https://github.com/AlexxIT/go2rtc/issues/235
		req.Header.Set("User-Agent", c.UserAgent)
	}

	res, err := c.Do(req)
	if err != nil {
		return err
	}

	if val := res.Header.Get("Content-Base"); val != "" {
		c.URL, err = urlParse(val)
		if err != nil {
			return err
		}
	}

	c.SDP = string(res.Body) // for info

	medias, err := UnmarshalSDP(res.Body)
	if err != nil {
		return err
	}

	if c.Media != "" {
		clone := make([]*core.Media, 0, len(medias))
		for _, media := range medias {
			if strings.Contains(c.Media, media.Kind) {
				clone = append(clone, media)
			}
		}
		medias = clone
	}

	// TODO: rewrite more smart
	if c.Medias == nil {
		c.Medias = medias
	} else if len(c.Medias) > len(medias) {
		c.Medias = c.Medias[:len(medias)]
	}

	c.mode = core.ModeActiveProducer

	return nil
}

func (c *Conn) Announce() (err error) {
	req := &tcp.Request{
		Method: MethodAnnounce,
		URL:    c.URL,
		Header: map[string][]string{
			"Content-Type": {"application/sdp"},
		},
	}

	req.Body, err = core.MarshalSDP(c.SessionName, c.Medias)
	if err != nil {
		return err
	}

	_, err = c.Do(req)
	return
}

func (c *Conn) Record() (err error) {
	req := &tcp.Request{
		Method: MethodRecord,
		URL:    c.URL,
		Header: map[string][]string{
			"Range": {"npt=0.000-"},
		},
	}

	_, err = c.Do(req)
	return
}

func (c *Conn) SetupMedia(media *core.Media) (byte, error) {
	var transport string
	var mediaIndex int = -1

	// try to use media position as channel number
	for i, m := range c.Medias {
		if m.Equal(media) {
			mediaIndex = i
			break
		}
	}

	if mediaIndex == -1 {
		return 0, fmt.Errorf("wrong media: %v", media)
	}

	if c.Transport == "udp" {
		transport, err := c.setupUDPTransport()
		if err != nil {
			return 0, err
		}

		return c.sendSetupRequest(media, transport)
	}

	transport = c.setupTCPTransport(mediaIndex)
	return c.sendSetupRequest(media, transport)
}

func (c *Conn) setupTCPTransport(mediaIndex int) string {
	channel := byte(mediaIndex * 2)
	transport := fmt.Sprintf("RTP/AVP/TCP;unicast;interleaved=%d-%d", channel, channel+1)
	return transport
}

func (c *Conn) setupUDPTransport() (string, error) {
	portPair, err := GetUDPPorts(nil, 10)
	if err != nil {
		return "", err
	}

	rtpChannel := c.getChannelForPort(portPair.RTPPort)
	rtcpChannel := c.getChannelForPort(portPair.RTCPPort)

	c.udpRtpListeners[rtpChannel] = &UDPConnection{
		Conn:    *portPair.RTPListener,
		Channel: rtpChannel,
	}

	c.udpRtcpListeners[rtcpChannel] = &UDPConnection{
		Conn:    *portPair.RTCPListener,
		Channel: rtcpChannel,
	}

	transport := fmt.Sprintf("RTP/AVP;unicast;client_port=%d-%d", portPair.RTPPort, portPair.RTCPPort)
	return transport, nil
}

func (c *Conn) sendSetupRequest(media *core.Media, transport string) (byte, error) {
	rawURL := media.ID // control
	if !strings.Contains(rawURL, "://") {
		rawURL = c.URL.String()
		// prefix check for https://github.com/AlexxIT/go2rtc/issues/1236
		if !strings.HasSuffix(rawURL, "/") && !strings.HasPrefix(media.ID, "/") {
			rawURL += "/"
		}
		rawURL += media.ID
	}
	trackURL, err := urlParse(rawURL)
	if err != nil {
		return 0, err
	}

	req := &tcp.Request{
		Method: MethodSetup,
		URL:    trackURL,
		Header: map[string][]string{
			"Transport": {transport},
		},
	}

	res, err := c.Do(req)
	if err != nil {
		// some Dahua/Amcrest cameras fail here because two simultaneous
		// backchannel connections
		if c.Backchannel {
			c.Backchannel = false
			if err = c.Reconnect(); err != nil {
				return 0, err
			}
			return c.SetupMedia(media)
		}

		return 0, err
	}

	if c.session == "" {
		// Session: 7116520596809429228
		// Session: 216525287999;timeout=60
		if s := res.Header.Get("Session"); s != "" {
			if i := strings.IndexByte(s, ';'); i > 0 {
				c.session = s[:i]
				if i = strings.Index(s, "timeout="); i > 0 {
					c.keepalive, _ = strconv.Atoi(s[i+8:])
				}
			} else {
				c.session = s
			}
		}
	}

	// Parse server response
	responseTransport := res.Header.Get("Transport")

	if c.Transport == "udp" {
		// Parse UDP response: client_ports=1234-1235;server_port=1234-1235
		var clientPorts []int
		var serverPorts []int

		if strings.Contains(transport, "client_port=") {
			parts := strings.Split(responseTransport, "client_port=")
			if len(parts) > 1 {
				portPart := strings.Split(strings.Split(parts[1], ";")[0], "-")
				for _, p := range portPart {
					if port, err := strconv.Atoi(p); err == nil {
						clientPorts = append(clientPorts, port)
					}
				}
			}
		}

		if strings.Contains(responseTransport, "server_port=") {
			parts := strings.Split(responseTransport, "server_port=")
			if len(parts) > 1 {
				portPart := strings.Split(strings.Split(parts[1], ";")[0], "-")
				for _, p := range portPart {
					if port, err := strconv.Atoi(p); err == nil {
						serverPorts = append(serverPorts, port)
					}
				}
			}
		}

		// Create UDP connections for RTP and RTCP if we have both server ports
		if len(serverPorts) >= 2 {
			if host, _, err := net.SplitHostPort(c.Connection.RemoteAddr); err == nil {
				rtpServerPort := serverPorts[0]
				rtcpServerPort := serverPorts[1]

				cleanHost := host
				if strings.Contains(cleanHost, ":") {
					cleanHost = fmt.Sprintf("[%s]", host)
				}

				remoteRtpAddr := fmt.Sprintf("%s:%d", cleanHost, rtpServerPort)
				remoteRtcpAddr := fmt.Sprintf("%s:%d", cleanHost, rtcpServerPort)

				if rtpAddr, err := net.ResolveUDPAddr("udp", remoteRtpAddr); err == nil {
					if rtpConn, err := net.DialUDP("udp", nil, rtpAddr); err == nil {
						channel := c.getChannelForPort(rtpServerPort)
						c.udpRtpConns[channel] = &UDPConnection{
							Conn:    *rtpConn,
							Channel: channel,
						}
					}
				}

				if rtcpAddr, err := net.ResolveUDPAddr("udp", remoteRtcpAddr); err == nil {
					if rtcpConn, err := net.DialUDP("udp", nil, rtcpAddr); err == nil {
						channel := c.getChannelForPort(rtcpServerPort)
						c.udpRtcpConns[channel] = &UDPConnection{
							Conn:    *rtcpConn,
							Channel: channel,
						}
					}
				}
			}
		}

		// Try to open a hole in the NAT router (to allow incoming UDP packets)
		// by send a UDP packet for RTP and RTCP to the remote RTSP server.
		go c.tryHolePunching(clientPorts, serverPorts)

		var rtpPort string
		if media.Direction == core.DirectionRecvonly {
			rtpPort = core.Between(transport, "client_port=", "-")
		} else {
			rtpPort = core.Between(responseTransport, "server_port=", "-")
		}

		i, err := strconv.Atoi(rtpPort)
		if err != nil {
			return 0, err
		}

		return c.getChannelForPort(i), nil

	} else {
		// we send our `interleaved`, but camera can answer with another

		// Transport: RTP/AVP/TCP;unicast;interleaved=10-11;ssrc=10117CB7
		// Transport: RTP/AVP/TCP;unicast;destination=192.168.1.111;source=192.168.1.222;interleaved=0
		// Transport: RTP/AVP/TCP;ssrc=22345682;interleaved=0-1
		if !strings.HasPrefix(responseTransport, "RTP/AVP/TCP;") {
			// Escam Q6 has a bug:
			// Transport: RTP/AVP;unicast;destination=192.168.1.111;source=192.168.1.222;interleaved=0-1
			if !strings.Contains(responseTransport, ";interleaved=") {
				return 0, fmt.Errorf("wrong transport: %s", responseTransport)
			}
		}

		channel := core.Between(responseTransport, "interleaved=", "-")
		i, err := strconv.Atoi(channel)
		if err != nil {
			return 0, err
		}

		return byte(i), nil
	}
}

func (c *Conn) Play() (err error) {
	req := &tcp.Request{Method: MethodPlay, URL: c.URL}
	return c.WriteRequest(req)
}

func (c *Conn) Teardown() (err error) {
	// allow TEARDOWN from any state (ex. ANNOUNCE > SETUP)
	req := &tcp.Request{Method: MethodTeardown, URL: c.URL}
	return c.WriteRequest(req)
}

func (c *Conn) Close() error {
	c.closeUDP()

	if c.mode == core.ModeActiveProducer {
		_ = c.Teardown()
	}

	if c.OnClose != nil {
		_ = c.OnClose()
	}

	return c.conn.Close()
}

func (c *Conn) closeUDP() {
	for _, listener := range c.udpRtpListeners {
		_ = listener.Conn.Close()
	}
	for _, listener := range c.udpRtcpListeners {
		_ = listener.Conn.Close()
	}
	for _, conn := range c.udpRtpConns {
		_ = conn.Conn.Close()
	}
	for _, conn := range c.udpRtcpConns {
		_ = conn.Conn.Close()
	}

	c.udpRtpListeners = make(map[byte]*UDPConnection)
	c.udpRtcpListeners = make(map[byte]*UDPConnection)
	c.udpRtpConns = make(map[byte]*UDPConnection)
	c.udpRtcpConns = make(map[byte]*UDPConnection)
	c.portToChannel = make(map[int]byte)
	c.channelCounter = 0
}

func (c *Conn) sendUDPRtpPacket(data []byte) error {
	for len(data) >= 4 && data[0] == '$' {
		channel := data[1]
		size := binary.BigEndian.Uint16(data[2:4])

		if len(data) < 4+int(size) {
			return fmt.Errorf("incomplete RTP packet: %d < %d", len(data), 4+size)
		}

		// Send RTP data without interleaved header
		rtpData := data[4 : 4+size]

		if conn, ok := c.udpRtpConns[channel]; ok {
			if err := conn.Conn.SetWriteDeadline(time.Now().Add(Timeout)); err != nil {
				return nil
			}

			if _, err := conn.Conn.Write(rtpData); err != nil {
				return err
			}
		}

		data = data[4+size:] // Move to next packet
	}

	return nil
}

func (c *Conn) tryHolePunching(clientPorts, serverPorts []int) {
	if len(clientPorts) < 2 || len(serverPorts) < 2 {
		return
	}

	host, _, _ := net.SplitHostPort(c.Connection.RemoteAddr)
	if strings.Contains(host, ":") {
		host = fmt.Sprintf("[%s]", host)
	}

	// RTP hole punch
	if rtpListener, ok := c.udpRtpListeners[c.getChannelForPort(clientPorts[0])]; ok {
		if addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", host, serverPorts[0])); err == nil {
			rtpListener.Conn.WriteToUDP([]byte{0x80, 0x00, 0x00, 0x00}, addr)
		}
	}

	// RTCP hole punch
	if rtcpListener, ok := c.udpRtcpListeners[c.getChannelForPort(clientPorts[1])]; ok {
		if addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", host, serverPorts[1])); err == nil {
			rtcpListener.Conn.WriteToUDP([]byte{0x80, 0xC8, 0x00, 0x01}, addr)
		}
	}
}

func (c *Conn) getChannelForPort(port int) byte {
	if channel, exists := c.portToChannel[port]; exists {
		return channel
	}

	c.channelCounter++
	if c.channelCounter == 0 {
		c.channelCounter = 1
	}

	channel := c.channelCounter
	c.portToChannel[port] = channel

	return channel
}