package homekit

import (
	"encoding/json"
	"errors"
	"fmt"
	"net"
	"net/url"
	"sync/atomic"
	"time"

	"github.com/AlexxIT/go2rtc/pkg/core"
	"github.com/AlexxIT/go2rtc/pkg/h264"
	"github.com/AlexxIT/go2rtc/pkg/hap"
	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
	"github.com/AlexxIT/go2rtc/pkg/srtp"
	"github.com/pion/rtp"
)

type Client struct {
	core.Listener

	conn   *hap.Client
	server *srtp.Server
	config *StreamConfig

	medias    []*core.Media
	receivers []*core.Receiver

	sessions []*srtp.Session
}

type StreamConfig struct {
	Video camera.SupportedVideoStreamConfig
	Audio camera.SupportedAudioStreamConfig
}

func NewClient(rawURL string, server *srtp.Server) (*Client, error) {
	u, err := url.Parse(rawURL)
	if err != nil {
		return nil, err
	}

	query := u.Query()
	c := &hap.Client{
		DeviceAddress: u.Host,
		DeviceID:      query.Get("device_id"),
		DevicePublic:  hap.DecodeKey(query.Get("device_public")),
		ClientID:      query.Get("client_id"),
		ClientPrivate: hap.DecodeKey(query.Get("client_private")),
	}

	return &Client{conn: c, server: server}, nil
}

func (c *Client) Dial() error {
	return c.conn.Dial()
}

func (c *Client) GetMedias() []*core.Media {
	if c.medias != nil {
		return c.medias
	}

	accs, err := c.conn.GetAccessories()
	if err != nil {
		return nil
	}

	acc := accs[0]

	c.config = &StreamConfig{}

	// get supported video config (not really necessary)
	char := acc.GetCharacter(camera.TypeSupportedVideoStreamConfiguration)
	if char == nil {
		return nil
	}
	if err = char.ReadTLV8(&c.config.Video); err != nil {
		return nil
	}

	for _, videoCodec := range c.config.Video.Codecs {
		var name string

		switch videoCodec.CodecType {
		case camera.VideoCodecTypeH264:
			name = core.CodecH264
		default:
			continue
		}

		for _, params := range videoCodec.CodecParams {
			codec := &core.Codec{
				Name:      name,
				ClockRate: 90000,
				FmtpLine:  "profile-level-id=",
			}

			switch params.ProfileID {
			case camera.VideoCodecProfileConstrainedBaseline:
				codec.FmtpLine += "4200" // 4240?
			case camera.VideoCodecProfileMain:
				codec.FmtpLine += "4D00" // 4D40?
			case camera.VideoCodecProfileHigh:
				codec.FmtpLine += "6400"
			default:
				continue
			}

			switch params.Level {
			case camera.VideoCodecLevel31:
				codec.FmtpLine += "1F"
			case camera.VideoCodecLevel32:
				codec.FmtpLine += "20"
			case camera.VideoCodecLevel40:
				codec.FmtpLine += "28"
			default:
				continue
			}

			media := &core.Media{
				Kind: core.KindVideo, Direction: core.DirectionRecvonly,
				Codecs: []*core.Codec{codec},
			}
			c.medias = append(c.medias, media)
		}
	}

	char = acc.GetCharacter(camera.TypeSupportedAudioStreamConfiguration)
	if char == nil {
		return nil
	}
	if err = char.ReadTLV8(&c.config.Audio); err != nil {
		return nil
	}

	for _, audioCodec := range c.config.Audio.Codecs {
		var name string

		switch audioCodec.CodecType {
		case camera.AudioCodecTypePCMU:
			name = core.CodecPCMU
		case camera.AudioCodecTypePCMA:
			name = core.CodecPCMA
		case camera.AudioCodecTypeAACELD:
			name = core.CodecELD
		case camera.AudioCodecTypeOpus:
			name = core.CodecOpus
		default:
			continue
		}

		for _, params := range audioCodec.CodecParams {
			codec := &core.Codec{
				Name:     name,
				Channels: uint16(params.Channels),
			}

			if name == core.CodecELD {
				// only this value supported by FFmpeg
				codec.FmtpLine = "profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=F8EC3000"
			}

			switch params.SampleRate {
			case camera.AudioCodecSampleRate8Khz:
				codec.ClockRate = 8000
			case camera.AudioCodecSampleRate16Khz:
				codec.ClockRate = 16000
			case camera.AudioCodecSampleRate24Khz:
				codec.ClockRate = 24000
			default:
				continue
			}

			media := &core.Media{
				Kind: core.KindAudio, Direction: core.DirectionRecvonly,
				Codecs: []*core.Codec{codec},
			}
			c.medias = append(c.medias, media)
		}
	}

	media := &core.Media{
		Kind:      core.KindVideo,
		Direction: core.DirectionRecvonly,
		Codecs: []*core.Codec{
			{
				Name:        core.CodecJPEG,
				ClockRate:   90000,
				PayloadType: core.PayloadTypeRAW,
			},
		},
	}
	c.medias = append(c.medias, media)

	return c.medias
}

func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
	for _, track := range c.receivers {
		if track.Codec == codec {
			return track, nil
		}
	}

	track := core.NewReceiver(media, codec)
	c.receivers = append(c.receivers, track)
	return track, nil
}

func (c *Client) Start() error {
	if c.receivers == nil {
		return errors.New("producer without tracks")
	}

	if c.receivers[0].Codec.Name == core.CodecJPEG {
		return c.startMJPEG()
	}

	// get our server local IP-address
	host, _, err := net.SplitHostPort(c.conn.LocalAddr())
	if err != nil {
		return err
	}

	videoParams := &camera.SelectedVideoParams{
		CodecType: camera.VideoCodecTypeH264,
		VideoAttrs: camera.VideoAttrs{
			Width: 1920, Height: 1080, Framerate: 30,
		},
	}

	videoTrack := c.trackByKind(core.KindVideo)
	if videoTrack != nil {
		profile := h264.GetProfileLevelID(videoTrack.Codec.FmtpLine)

		switch profile[:2] {
		case "42":
			videoParams.CodecParams.ProfileID = camera.VideoCodecProfileConstrainedBaseline
		case "4D":
			videoParams.CodecParams.ProfileID = camera.VideoCodecProfileMain
		case "64":
			videoParams.CodecParams.ProfileID = camera.VideoCodecProfileHigh
		}

		switch profile[4:] {
		case "1F":
			videoParams.CodecParams.Level = camera.VideoCodecLevel31
		case "20":
			videoParams.CodecParams.Level = camera.VideoCodecLevel32
		case "28":
			videoParams.CodecParams.Level = camera.VideoCodecLevel40
		}
	} else {
		// if consumer don't need track - ask first track from camera
		codec0 := c.config.Video.Codecs[0]
		videoParams.CodecParams.ProfileID = codec0.CodecParams[0].ProfileID
		videoParams.CodecParams.Level = codec0.CodecParams[0].Level
	}

	audioParams := &camera.SelectedAudioParams{
		CodecParams: camera.AudioCodecParams{
			Bitrate: camera.AudioCodecBitrateVariable,
			// RTPTime=20 => AAC-ELD packet size=480
			// RTPTime=30 => AAC-ELD packet size=480
			// RTPTime=40 => AAC-ELD packet size=480
			// RTPTime=60 => AAC-LD  packet size=960
			RTPTime: 40,
		},
	}

	audioTrack := c.trackByKind(core.KindAudio)
	if audioTrack != nil {
		audioParams.CodecParams.Channels = byte(audioTrack.Codec.Channels)

		switch audioTrack.Codec.Name {
		case core.CodecPCMU:
			audioParams.CodecType = camera.AudioCodecTypePCMU
		case core.CodecPCMA:
			audioParams.CodecType = camera.AudioCodecTypePCMA
		case core.CodecELD:
			audioParams.CodecType = camera.AudioCodecTypeAACELD
		case core.CodecOpus:
			audioParams.CodecType = camera.AudioCodecTypeOpus
		}

		switch audioTrack.Codec.ClockRate {
		case 8000:
			audioParams.CodecParams.SampleRate = camera.AudioCodecSampleRate8Khz
		case 16000:
			audioParams.CodecParams.SampleRate = camera.AudioCodecSampleRate16Khz
		case 24000:
			audioParams.CodecParams.SampleRate = camera.AudioCodecSampleRate24Khz
		}
	} else {
		// if consumer don't need track - ask first track from camera
		codec0 := c.config.Audio.Codecs[0]
		audioParams.CodecType = codec0.CodecType
		audioParams.CodecParams.Channels = codec0.CodecParams[0].Channels
		audioParams.CodecParams.SampleRate = codec0.CodecParams[0].SampleRate
	}

	// setup HomeKit stream session
	session := camera.NewSession(videoParams, audioParams)
	session.SetLocalEndpoint(host, c.server.Port())

	// create client for processing camera accessory
	cam := camera.NewClient(c.conn)
	// try to start HomeKit stream
	if err = cam.StartStream(session); err != nil {
		return err
	}

	// SRTP Video Session
	videoSession := &srtp.Session{
		LocalSSRC:  session.Config.VideoParams.RTPParams.SSRC,
		RemoteSSRC: session.Answer.VideoSSRC,
		Track:      videoTrack,
	}
	if err = videoSession.SetKeys(
		session.Offer.VideoCrypto.MasterKey, session.Offer.VideoCrypto.MasterSalt,
		session.Answer.VideoCrypto.MasterKey, session.Answer.VideoCrypto.MasterSalt,
	); err != nil {
		return err
	}

	// SRTP Audio Session
	audioSession := &srtp.Session{
		LocalSSRC:  session.Config.AudioParams.RTPParams.SSRC,
		RemoteSSRC: session.Answer.AudioSSRC,
		Track:      audioTrack,
	}
	if err = audioSession.SetKeys(
		session.Offer.AudioCrypto.MasterKey, session.Offer.AudioCrypto.MasterSalt,
		session.Answer.AudioCrypto.MasterKey, session.Answer.AudioCrypto.MasterSalt,
	); err != nil {
		return err
	}

	c.server.AddSession(videoSession)
	c.server.AddSession(audioSession)

	c.sessions = []*srtp.Session{videoSession, audioSession}

	if audioSession.Track != nil {
		audioSession.Deadline = time.NewTimer(core.ConnDeadline)
		<-audioSession.Deadline.C
	} else if videoSession.Track != nil {
		videoSession.Deadline = time.NewTimer(core.ConnDeadline)
		<-videoSession.Deadline.C
	}

	return nil
}

func (c *Client) Stop() error {
	for _, session := range c.sessions {
		c.server.RemoveSession(session)
	}

	return c.conn.Close()
}

func (c *Client) MarshalJSON() ([]byte, error) {
	var recv uint32
	for _, session := range c.sessions {
		recv += atomic.LoadUint32(&session.Recv)
	}

	info := &core.Info{
		Type:      "HomeKit active producer",
		URL:       c.conn.URL(),
		SDP:       fmt.Sprintf("%+v", *c.config),
		Medias:    c.medias,
		Receivers: c.receivers,
		Recv:      int(recv),
	}
	return json.Marshal(info)
}

func (c *Client) trackByKind(kind string) *core.Receiver {
	for _, receiver := range c.receivers {
		if core.GetKind(receiver.Codec.Name) == kind {
			return receiver
		}
	}
	return nil
}

func (c *Client) startMJPEG() error {
	receiver := c.receivers[0]

	for {
		b, err := c.conn.GetImage(1920, 1080)
		if err != nil {
			return err
		}

		packet := &rtp.Packet{
			Header:  rtp.Header{Timestamp: core.Now90000()},
			Payload: b,
		}
		receiver.WriteRTP(packet)
	}
}