package csgo

import (
	"context"
	"csgowtfd/ent"
	"csgowtfd/ent/match"
	"csgowtfd/utils"
	"encoding/json"
	"fmt"
	"github.com/an0nfunc/go-steam/v3"
	"github.com/an0nfunc/go-steam/v3/csgo/protocol/protobuf"
	"github.com/an0nfunc/go-steam/v3/netutil"
	"github.com/an0nfunc/go-steam/v3/protocol/gamecoordinator"
	"github.com/an0nfunc/go-steam/v3/protocol/steamlang"
	log "github.com/sirupsen/logrus"
	"go.uber.org/ratelimit"
	"google.golang.org/protobuf/proto"
	"io/ioutil"
	"math/rand"
	"os"
	"sync"
	"time"
)

//goland:noinspection SpellCheckingInspection
const (
	APPID = 730
)

type DemoMatchLoaderConfig struct {
	Username   string
	Password   string
	AuthCode   string
	Sentry     string
	LoginKey   string
	ServerList string
	Db         *ent.Client
	Lock       *sync.RWMutex
	Worker     int
	ApiKey     string
	RateLimit  ratelimit.Limiter
}

type DemoMatchLoader struct {
	client     *steam.Client
	GCReady    bool
	steamLogin *steam.LogOnDetails
	matchRecv  chan *protobuf.CMsgGCCStrike15V2_MatchList
	cmList     []*netutil.PortAddr
	sentryFile string
	loginKey   string
	serverList string
	db         *ent.Client
	lock       *sync.RWMutex
	dp         *DemoParser
	parseDemo  chan *Demo
}

func AccountId2SteamId(accId uint32) uint64 {
	return uint64(accId) + 76561197960265728
}

func SteamId2AccountId(steamId uint64) uint32 {
	return uint32(steamId - 76561197960265728)
}

func (d *DemoMatchLoader) HandleGCPacket(pkg *gamecoordinator.GCPacket) {
	switch pkg.MsgType {
	case uint32(protobuf.EGCBaseClientMsg_k_EMsgGCClientWelcome):
		msg := &protobuf.CMsgClientWelcome{}
		err := proto.Unmarshal(pkg.Body, msg)
		if err != nil {
			log.Errorf("[DL] Unable to unmarshal event %v: %v", pkg.MsgType, err)
		}
		log.Debugf("[GC] Welcome: %+v", msg)
		d.GCReady = true
	case uint32(protobuf.EGCBaseClientMsg_k_EMsgGCClientConnectionStatus):
		msg := &protobuf.CMsgConnectionStatus{}
		err := proto.Unmarshal(pkg.Body, msg)
		if err != nil {
			log.Errorf("[DL] Unable to unmarshal event %v: %v", pkg.MsgType, err)
		}

		log.Debugf("[GC] Status: %+v", msg)
		if msg.GetStatus() != protobuf.GCConnectionStatus_GCConnectionStatus_HAVE_SESSION {
			d.GCReady = false
			go d.greetGC()
		}
	case uint32(protobuf.ECsgoGCMsg_k_EMsgGCCStrike15_v2_GC2ClientGlobalStats):
		msg := &protobuf.GlobalStatistics{}
		err := proto.Unmarshal(pkg.Body, msg)
		if err != nil {
			log.Errorf("[DL] Unable to unmarshal event %v: %v", pkg.MsgType, err)
		}
		log.Debugf("[GC] Stats: %+v", msg)
		d.GCReady = true
	case uint32(protobuf.ECsgoGCMsg_k_EMsgGCCStrike15_v2_MatchList):
		msg := &protobuf.CMsgGCCStrike15V2_MatchList{}
		err := proto.Unmarshal(pkg.Body, msg)
		if err != nil {
			log.Errorf("[DL] Unable to unmarshal event %v: %v", pkg.MsgType, err)
		}
		d.matchRecv <- msg
	default:
		log.Debugf("[GC] Unhandled GC message: %+v", pkg)
	}
}

func (d *DemoMatchLoader) getMatchDetails(sharecode string) (*protobuf.CMsgGCCStrike15V2_MatchList, error) {
	if !d.GCReady {
		return nil, fmt.Errorf("gc not ready")
	}

	matchId, outcomeId, tokenId, err := DecodeSharecode(sharecode)
	if err != nil {
		return nil, err
	}
	err = d.requestDemoInfo(matchId, outcomeId, tokenId)
	if err != nil {
		return nil, err
	}

	for {
		select {
		case matchDetails := <-d.matchRecv:
			if *matchDetails.Matches[0].Matchid == matchId {
				return matchDetails, nil
			} else {
				d.matchRecv <- matchDetails
			}
		}
	}
}

func (d *DemoMatchLoader) getRandomCM() *netutil.PortAddr {
	return d.cmList[rand.Intn(len(d.cmList))]
}

func (d *DemoMatchLoader) connectToSteam() error {
	if d.cmList != nil {
		err := d.client.ConnectTo(d.getRandomCM())
		if err != nil {
			return err
		}
	} else {
		_, err := d.client.Connect()
		if err != nil {
			return err
		}
	}
	return nil
}

func (d *DemoMatchLoader) Setup(config *DemoMatchLoaderConfig) error {
	d.loginKey = config.LoginKey
	d.sentryFile = config.Sentry
	d.serverList = config.ServerList
	d.lock = config.Lock
	d.db = config.Db
	d.dp = &DemoParser{}
	err := d.dp.Setup(config.Db, config.Lock, config.Worker)
	if err != nil {
		return err
	}

	d.steamLogin = new(steam.LogOnDetails)
	d.steamLogin.Username = config.Username
	d.steamLogin.Password = config.Password
	d.steamLogin.AuthCode = config.AuthCode
	d.steamLogin.ShouldRememberPassword = true

	if _, err := os.Stat(d.sentryFile); err == nil {
		hash, err := ioutil.ReadFile(d.sentryFile)
		if err != nil {
			return err
		}
		d.steamLogin.SentryFileHash = hash
	}

	if _, err := os.Stat(d.loginKey); err == nil {
		hash, err := ioutil.ReadFile(d.loginKey)
		if err != nil {
			return err
		}
		d.steamLogin.LoginKey = string(hash)
	}

	if _, err := os.Stat(d.serverList); err == nil {
		rawJson, err := ioutil.ReadFile(d.serverList)
		if err != nil {
			return err
		}
		err = json.Unmarshal(rawJson, &d.cmList)
		if err != nil {
			return err
		}
	}

	d.client = steam.NewClient()
	d.matchRecv = make(chan *protobuf.CMsgGCCStrike15V2_MatchList, 1000)
	d.parseDemo = make(chan *Demo, 1000)

	go d.connectLoop()
	go d.steamEventHandler()

	for i := 0; i < config.Worker; i++ {
		go d.gcWorker(config.ApiKey, config.RateLimit)
	}

	return nil
}

func (d DemoMatchLoader) LoadDemo(demo *Demo) error {
	select {
	case d.parseDemo <- demo:
		return nil
	default:
		return fmt.Errorf("queue full")
	}
}

func (d DemoMatchLoader) connectLoop() {
	for d.connectToSteam() != nil {
		log.Infof("Retrying connecting to steam")
		time.Sleep(time.Second)
	}
}

func (d *DemoMatchLoader) steamEventHandler() {
	for event := range d.client.Events() {
		switch e := event.(type) {
		case *steam.ConnectedEvent:
			log.Debug("[DL] Connected!")
			d.client.Auth.LogOn(d.steamLogin)
		case *steam.ClientCMListEvent:
			log.Debug("[DL] CM list")
			serverJson, err := json.Marshal(e.Addresses)
			if err != nil {
				log.Errorf("[DL] Unable to marshal JSON: %v", err)
			}

			err = ioutil.WriteFile(d.serverList, serverJson, os.ModePerm)
			if err != nil {
				log.Errorf("[DL] Unable to write server list: %v", err)
			}
		case *steam.MachineAuthUpdateEvent:
			log.Debug("[DL] Got sentry!")
			err := ioutil.WriteFile(d.sentryFile, e.Hash, os.ModePerm)
			if err != nil {
				log.Errorf("[DL] Unable write sentry file: %v", err)
			}
		case *steam.LoggedOnEvent:
			log.Debug("[DL] Login successfully!")
			d.client.Social.SetPersonaState(steamlang.EPersonaState_Online)
			go d.setPlaying()
		case *steam.LogOnFailedEvent:
			log.Warningf("[DL] Steam login denied: %+v", e)
			switch e.Result {
			case steamlang.EResult_AccountLogonDenied:
				log.Fatalf("[DL] Please provide AuthCode with --authcode")
			case steamlang.EResult_InvalidPassword:
				_ = os.Remove(d.sentryFile)
				_ = os.Remove(d.loginKey)
				log.Fatalf("[DL] Steam login wrong")
			case steamlang.EResult_InvalidLoginAuthCode:
				log.Fatalf("[DL] Steam auth code wrong")
			}
		case *steam.DisconnectedEvent:
			log.Warningf("Steam disconnected, trying to reconnect...")
			_, err := d.client.Connect()
			if err != nil {
				log.Errorf("[DL] Unable to reconnect to steam: %v", err)
			}
		case *steam.LoginKeyEvent:
			log.Debug("Got login_key!")
			err := ioutil.WriteFile(d.loginKey, []byte(e.LoginKey), os.ModePerm)
			if err != nil {
				log.Errorf("[DL] Unable write login_key: %v", err)
			}
		case steam.FatalErrorEvent:
			log.Debugf("[DL] Got FatalError %+v", e)
		case error:
			log.Fatalf("[DL] Got error %+v", e)
		default:
			log.Debugf("[DL] %T: %v", e, e)
		}
	}
}

func (d *DemoMatchLoader) setPlaying() {
	d.client.GC.SetGamesPlayed(APPID)
	d.client.GC.RegisterPacketHandler(d)
	go d.greetGC()
}

func (d *DemoMatchLoader) greetGC() {
	for !d.GCReady {
		log.Debugf("[DL] Sending GC greeting")
		msg := protobuf.CMsgClientHello{}
		d.client.GC.Write(gamecoordinator.NewGCMsgProtobuf(APPID, uint32(protobuf.EGCBaseClientMsg_k_EMsgGCClientHello), &msg))
		time.Sleep(500 * time.Millisecond)
	}
}

func (d *DemoMatchLoader) requestDemoInfo(matchId uint64, conclusionId uint64, tokenId uint32) error {
	if !d.GCReady {
		return fmt.Errorf("gc not ready")
	}

	msg := protobuf.CMsgGCCStrike15V2_MatchListRequestFullGameInfo{Matchid: &matchId,
		Outcomeid: &conclusionId,
		Token:     &tokenId}

	d.client.GC.Write(gamecoordinator.NewGCMsgProtobuf(APPID, uint32(protobuf.ECsgoGCMsg_k_EMsgGCCStrike15_v2_MatchListRequestFullGameInfo), &msg))

	return nil
}

func (d *DemoMatchLoader) gcWorker(apiKey string, rl ratelimit.Limiter) {
	for {
		select {
		case demo := <-d.parseDemo:
			if !d.GCReady {
				time.Sleep(5 * time.Second)
				d.parseDemo <- demo
				continue
			}

			matchId, _, _, err := DecodeSharecode(demo.ShareCode)
			if err != nil || matchId == 0 {
				log.Warningf("[DL] Can't parse match with sharecode %s: %v", demo.ShareCode, err)
				continue
			}

			d.lock.RLock()
			iMatch, err := d.db.Match.Query().Where(match.ID(matchId)).Only(context.Background())
			d.lock.RUnlock()
			if err != nil {
				switch e := err.(type) {
				case *ent.NotFoundError:
					break
				default:
					log.Errorf("[DL] Failure trying to find match %d in db: %v", matchId, e)
				}
			} else {
				if iMatch.DemoParsed == false && iMatch.Date.Before(time.Now().UTC().AddDate(0, 0, -30)) {
					log.Infof("[DL] Match %d is loaded, but not parsed. Try parsing.", demo.MatchId)
					demo.MatchId = matchId
					demo.Url = iMatch.ReplayURL
					err := d.dp.ParseDemo(demo)
					if err != nil {
						log.Warningf("[DL] Parsing demo from match %d failed: %v", demo.MatchId, err)
					}
					continue
				}

				log.Debugf("[DL] Skipped match %d: already parsed", matchId)
				continue
			}

			matchDetails, err := d.getMatchDetails(demo.ShareCode)
			if err != nil {
				log.Warningf("[DL] Failure to get match-details for %d from GC: %v", demo.MatchId, err)
				continue
			}
			matchZero := matchDetails.GetMatches()[0]
			lastRound := matchZero.GetRoundstatsall()[len(matchZero.Roundstatsall)-1]
			var players []*ent.Player

			for _, accountId := range lastRound.GetReservation().GetAccountIds() {
				tPlayer, err := utils.GetPlayer(&utils.DBWithLock{
					Client: d.db,
					Lock:   d.lock,
				}, AccountId2SteamId(accountId), apiKey, rl)
				if err != nil {
					log.Warningf("[DL] Unable to get player for steamid %d: %v", AccountId2SteamId(accountId), err)
					continue
				}
				players = append(players, tPlayer)
			}

			demo.Url = lastRound.GetMap()
			demo.MatchId = matchZero.GetMatchid()

			d.lock.Lock()
			tMatch, err := d.db.Match.Create().
				SetID(matchZero.GetMatchid()).
				AddPlayers(players...).
				SetDate(time.Unix(int64(matchZero.GetMatchtime()), 0).UTC()).
				SetMaxRounds(int(lastRound.GetMaxRounds())).
				SetDuration(int(lastRound.GetMatchDuration())).
				SetShareCode(demo.ShareCode).
				SetReplayURL(lastRound.GetMap()).
				SetScoreTeamA(int(lastRound.GetTeamScores()[0])).
				SetScoreTeamB(int(lastRound.GetTeamScores()[1])).
				SetMatchResult(int(lastRound.GetMatchResult())).
				Save(context.Background())
			d.lock.Unlock()
			if err != nil {
				log.Warningf("[DL] Unable to create match %d: %v", matchZero.GetMatchid(), err)
				continue
			}

			for i, mPlayer := range players {
				var teamId int
				if i > 4 {
					teamId = 2
				} else {
					teamId = 1
				}
				d.lock.Lock()
				err := d.db.Stats.Create().
					SetMatches(tMatch).
					SetPlayers(mPlayer).
					SetTeamID(teamId).
					SetKills(int(lastRound.GetKills()[i])).
					SetDeaths(int(lastRound.GetDeaths()[i])).
					SetAssists(int(lastRound.GetAssists()[i])).
					SetMvp(int(lastRound.GetMvps()[i])).
					SetScore(int(lastRound.GetScores()[i])).
					SetHeadshot(int(lastRound.GetEnemyHeadshots()[i])).
					Exec(context.Background())
				d.lock.Unlock()
				if err != nil {
					log.Warningf("[DL] Unable to create stats for player %d in match %d: %v", mPlayer.ID, tMatch.ID, err)
				}
			}

			err = d.dp.ParseDemo(demo)
			if err != nil {
				log.Warningf("[DL] Can't queue demo %d for parsing: %v", demo.MatchId, err)
			}
		}
	}
}