package domain

import (
	"bytes"
	"errors"
	"fmt"
	"net"
	"strings"
	"time"

	"github.com/libretro/netplay-lobby-server-go/model/entity"
)

// SessionDeadline 是一个会话在没有收到任何更新的情况下的生命周期（以秒为单位）。
const SessionDeadline = 60

// RateLimit 是客户端可以发送更新的最大速率（每五秒）。
const RateLimit = 5

// requestType 枚举
type requestType int

// SessionAddType 枚举值
const (
	SessionCreate requestType = iota
	SessionUpdate
	SessionTouch
)

// AddSessionRequest 定义了 SessionDomain.Add() 请求的请求结构。
type AddSessionRequest struct {
	Username            string `form:"username"`
	CoreName            string `form:"core_name"`
	CoreVersion         string `form:"core_version"`
	GameName            string `form:"game_name"`
	GameCRC             string `form:"game_crc"`
	Port                uint16 `form:"port"`
	MITMServer          string `form:"mitm_server"`
	HasPassword         bool   `form:"has_password"` // 1/0（可以绑定到 bool 吗？）
	HasSpectatePassword bool   `form:"has_spectate_password"`
	ForceMITM           bool   `form:"force_mitm"`
	RetroArchVersion    string `form:"retroarch_version"`
	Frontend            string `form:"frontend"`
	SubsystemName       string `form:"subsystem_name"`
	MITMSession         string `form:"mitm_session"`
	MITMCustomServer    string `form:"mitm_custom_addr"`
	MITMCustomPort      uint16 `form:"mitm_custom_port"`
}

// ErrSessionRejected 当会话被域逻辑拒绝时抛出。
var ErrSessionRejected = errors.New("会话被拒绝")

// ErrRateLimited 当达到特定会话的速率限制时抛出。
var ErrRateLimited = errors.New("速率限制已达到")

// SessionRepository 接口用于将域逻辑与存储库代码解耦。
type SessionRepository interface {
	Create(s *entity.Session) error
	GetByID(id string) (*entity.Session, error)
	GetByRoomID(roomID int32) (*entity.Session, error)
	GetAll(deadline time.Time) ([]entity.Session, error)
	Update(s *entity.Session) error
	Touch(id string) error
	PurgeOld(deadline time.Time) error
}

// SessionDomain 抽象了 netplay 会话处理的域逻辑。
type SessionDomain struct {
	sessionRepo      SessionRepository
	geopip2Domain    *GeoIP2Domain
	validationDomain *ValidationDomain
	mitmDomain       *MitmDomain
}

// NewSessionDomain 返回一个初始化的 SessionDomain 结构。
func NewSessionDomain(
	sessionRepo SessionRepository,
	geoIP2Domain *GeoIP2Domain,
	validationDomain *ValidationDomain,
	mitmDomain *MitmDomain) *SessionDomain {
	return &SessionDomain{sessionRepo, geoIP2Domain, validationDomain, mitmDomain}
}

// Add 添加或更新会话，基于来自给定 IP 的传入请求。
// 如果会话被拒绝，则返回 ErrSessionRejected。
// 如果达到会话的速率限制，则返回 ErrRateLimited。
func (d *SessionDomain) Add(request *AddSessionRequest, ip net.IP) (*entity.Session, error) {
	var err error
	var savedSession *entity.Session
	var requestType requestType = SessionCreate

	session := d.parseSession(request, ip)

	if session.IP == nil || session.Port == 0 {
		return nil, errors.New("IP 或端口未设置")
	}

	// 决定这是 CREATE、UPDATE 还是 TOUCH 操作
	session.CalculateID()
	session.CalculateContentHash()
	if savedSession, err = d.sessionRepo.GetByID(session.ID); err != nil {
		return nil, fmt.Errorf("无法获取已保存的会话: %w", err)
	}
	if savedSession != nil {
		session.RoomID = savedSession.RoomID
		session.Country = savedSession.Country
		session.Connectable = savedSession.Connectable
		session.IsRetroArch = savedSession.IsRetroArch
		session.CreatedAt = savedSession.CreatedAt
		session.UpdatedAt = savedSession.UpdatedAt
		if savedSession.ContentHash != session.ContentHash {
			requestType = SessionUpdate
		} else {
			requestType = SessionTouch
		}
	}

	// 在 UPDATE 或 TOUCH 上进行速率限制
	if requestType == SessionUpdate || requestType == SessionTouch {
		threshold := time.Now().Add(-5 * time.Second)
		if savedSession.UpdatedAt.After(threshold) {
			return nil, ErrRateLimited
		}
	}

	if requestType == SessionCreate || requestType == SessionUpdate {
		// 在 CREATE 和 UPDATE 上验证会话
		if !d.validateSession(session) {
			return nil, ErrSessionRejected
		}
	}

	// 持久化会话更改
	switch requestType {
	case SessionCreate:
		if session.Country, err = d.geopip2Domain.GetCountryCodeForIP(session.IP); err != nil {
			return nil, fmt.Errorf("无法找到给定 IP %s 的国家: %w", session.IP, err)
		}

		d.trySessionConnect(session)

		if err = d.sessionRepo.Create(session); err != nil {
			return nil, fmt.Errorf("无法创建新会话: %w", err)
		}
	case SessionUpdate:
		d.trySessionConnect(session)

		if err = d.sessionRepo.Update(session); err != nil {
			return nil, fmt.Errorf("无法更新旧会话: %w", err)
		}
	case SessionTouch:
		if !session.Connectable {
			d.trySessionConnect(session)
			if session.Connectable {
				if err = d.sessionRepo.Update(session); err != nil {
					return nil, fmt.Errorf("无法更新旧会话: %w", err)
				}
				break
			}
		}

		if err = d.sessionRepo.Touch(session.ID); err != nil {
			return nil, fmt.Errorf("无法触碰旧会话: %w", err)
		}
	}

	return session, nil
}

// Get 返回具有给定 RoomID 的会话
func (d *SessionDomain) Get(roomID int32) (*entity.Session, error) {
	session, err := d.sessionRepo.GetByRoomID(roomID)
	if err != nil {
		return nil, err
	}

	return session, nil
}

// List 返回当前正在托管的所有会话的列表
func (d *SessionDomain) List() ([]entity.Session, error) {
	sessions, err := d.sessionRepo.GetAll(d.getDeadline())
	if err != nil {
		return nil, err
	}

	return sessions, nil
}

// PurgeOld 删除所有超过 45 秒未更新的会话。
func (d *SessionDomain) PurgeOld() error {
	if err := d.sessionRepo.PurgeOld(d.getDeadline()); err != nil {
		return err
	}

	return nil
}

// parseSession 将请求转换为可以与持久化会话进行比较的会话信息
func (d *SessionDomain) parseSession(req *AddSessionRequest, ip net.IP) *entity.Session {
	var hostMethod entity.HostMethod = entity.HostMethodUnknown
	var mitmHandle string = ""
	var mitmAddress string = ""
	var mitmPort uint16 = 0
	var mitmSession string = ""

	// 设置默认用户名
	if req.Username == "" {
		req.Username = "匿名"
	}

	if req.ForceMITM && req.MITMServer != "" && req.MITMSession != "" {
		if req.MITMServer == "custom" {
			if req.MITMCustomServer != "" && req.MITMCustomPort != 0 {
				hostMethod = entity.HostMethodMITM
				mitmHandle = req.MITMServer
				mitmAddress = req.MITMCustomServer
				mitmPort = req.MITMCustomPort
				mitmSession = req.MITMSession
			}
		} else {
			if info := d.GetTunnel(req.MITMServer); info != nil {
				hostMethod = entity.HostMethodMITM
				mitmHandle = req.MITMServer
				mitmAddress = info.Address
				mitmPort = info.Port
				mitmSession = req.MITMSession
			}
		}
	}

	return &entity.Session{
		Username:            req.Username,
		GameName:            req.GameName,
		GameCRC:             strings.ToUpper(req.GameCRC),
		CoreName:            req.CoreName,
		CoreVersion:         req.CoreVersion,
		SubsystemName:       req.SubsystemName,
		RetroArchVersion:    req.RetroArchVersion,
		Frontend:            req.Frontend,
		IP:                  ip,
		Port:                req.Port,
		MitmHandle:          mitmHandle,
		MitmAddress:         mitmAddress,
		MitmPort:            mitmPort,
		MitmSession:         mitmSession,
		HostMethod:          hostMethod,
		HasPassword:         req.HasPassword,
		HasSpectatePassword: req.HasSpectatePassword,
	}
}

// validateSession 验证传入的会话
func (d *SessionDomain) validateSession(s *entity.Session) bool {
	if len(s.Username) > 32 ||
		len(s.CoreName) > 255 ||
		len(s.GameName) > 255 ||
		len(s.GameCRC) != 8 ||
		len(s.RetroArchVersion) > 32 ||
		len(s.CoreVersion) > 255 ||
		len(s.SubsystemName) > 255 ||
		len(s.Frontend) > 255 ||
		len(s.MitmSession) > 32 {
		return false
	}

	if !d.validationDomain.ValidateString(s.Username) ||
		!d.validationDomain.ValidateString(s.CoreName) ||
		!d.validationDomain.ValidateString(s.CoreVersion) ||
		!d.validationDomain.ValidateString(s.Frontend) ||
		!d.validationDomain.ValidateString(s.SubsystemName) ||
		!d.validationDomain.ValidateString(s.RetroArchVersion) {
		return false
	}

	return true
}

// trySessionConnect 测试会话是否可连接以及是否为 RetroArch
func (d *SessionDomain) trySessionConnect(s *entity.Session) error {
	s.Connectable = true
	s.IsRetroArch = true

	// 如果是 MITM，假设既可连接又是 RetroArch
	if s.HostMethod == entity.HostMethodMITM {
		return nil
	}

	address := fmt.Sprintf("%s:%d", s.IP, s.Port)
	conn, err := net.DialTimeout("tcp", address, time.Second*3)
	if err != nil {
		s.Connectable = false
		return err
	}

	ranp := []byte{0x52, 0x41, 0x4E, 0x50} // RANP
	full := []byte{0x46, 0x55, 0x4C, 0x4C} // FULL
	poke := []byte{0x50, 0x4F, 0x4B, 0x45} // POKE
	magic := make([]byte, 4)

	// 忽略写入错误
	conn.SetWriteDeadline(time.Now().Add(time.Second * 3))
	conn.Write(poke)

	conn.SetReadDeadline(time.Now().Add(time.Second * 3))
	read, err := conn.Read(magic)

	conn.Close()

	// 在接收错误时假设它是 RetroArch
	if err != nil || read == 0 {
		return err
	}

	// 在不完整的魔术上假设它不是 RetroArch
	if read != len(magic) {
		s.IsRetroArch = false
	} else if !bytes.Equal(magic, ranp) && !bytes.Equal(magic, full) {
		s.IsRetroArch = false
	}

	return nil
}

func (d *SessionDomain) getDeadline() time.Time {
	return time.Now().Add(-SessionDeadline * time.Second)
}

// GetTunnel 返回隧道的地址/端口对。
func (d *SessionDomain) GetTunnel(tunnelName string) *MitmInfo {
	return d.mitmDomain.GetInfo(tunnelName)
}