package model

import (
	"encoding/json"
	"errors"
	"fmt"
	"time"

	"github.com/iapologizewhenimwrong/Vestmore_GO/utils/log"
	"gorm.io/gorm"
)

type KillaraCustomerTokenModel struct {
	// fields ...
	db        *gorm.DB
	TableName string // 表名
}

// 旧的php逻辑 不是一致操作, 存在bug的可能性.
// func (m *KillaraCustomerTokenModel) InsertToken(data *KillaraCustomerToken) error {
// 	// 删除重复的 token

// 	m.DeleteToken(*data.Token)

// 	// 删除相同客户ID和平台的旧 token
// 	if *data.CustomerId != 0 && *data.Platform != 0 {
// 		m.db.Where("customer_id = ? AND platform = ?", *data.CustomerId, *data.Platform).Delete(&KillaraCustomerToken{})
// 	}

// 	return m.db.Create(data).Error
// }

func (m *KillaraCustomerTokenModel) InsertToken(data *KillaraCustomerToken) error {
	return m.db.Model(&KillaraCustomerToken{}).Transaction(func(tx *gorm.DB) error {
		// 查找是否存在相同客户ID、平台和Token的记录
		var existingToken KillaraCustomerToken

		err := tx.Where("customer_id = ? AND platform = ? AND token = ?", data.CustomerId, data.Platform, *data.Token).First(&existingToken).Error

		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			tx.Rollback() // 发生错误,回滚事务
			return err
		}

		if !errors.Is(err, gorm.ErrRecordNotFound) {
			// 存在记录,先删除
			err = tx.Delete(&existingToken).Error
			if err != nil {
				tx.Rollback() // 删除错误,回滚事务
				return err
			}
		}

		// 插入新记录
		err = tx.Create(data).Error
		if err != nil {
			tx.Rollback() // 插入错误,回滚事务
			return err
		}

		return err // 提交事务
	})
}

func (m *KillaraCustomerTokenModel) UpdateTokenData(token string, data map[string]interface{}) error {
	dataJSON, err := json.Marshal(data)
	if err != nil {
		return err
	}
	return m.db.Model(&KillaraCustomerToken{}).Where("token = ?", token).Update("data", string(dataJSON)).Error
}

func (m *KillaraCustomerTokenModel) UpdateTokenExpiry(token string, expiry int64) error {
	return m.db.Model(&KillaraCustomerToken{}).Where("token = ?", token).Update("expiry", expiry).Error
}

func (m *KillaraCustomerTokenModel) UpdateTokenCustomerID(token string, customerID uint64) error {
	return m.db.Model(&KillaraCustomerToken{}).Where("token = ?", token).Update("customer_id", customerID).Error
}

func (m *KillaraCustomerTokenModel) DeleteToken(token string) error {
	err := m.db.Where("token = ?", token).Delete(&KillaraCustomerToken{}).Error
	if err == gorm.ErrRecordNotFound {
		return nil
	}
	return err
}

func (m *KillaraCustomerTokenModel) GetToken(tx *gorm.DB, token string) (*KillaraCustomerToken, error) {
	var db *gorm.DB
	if tx != nil {
		db = tx
	} else {
		db = m.db
	}

	var tokenData KillaraCustomerToken
	err := db.Model(&tokenData).Where("token = ?", token).First(&tokenData).Error
	if err == gorm.ErrRecordNotFound {
		return nil, nil
	}
	return &tokenData, err
}

// PHP 旧的代码
// func (m *KillaraCustomerTokenModel) CheckToken(token string) (*KillaraCustomerToken, error) {
// 	tokenData, err := m.GetToken(token)
// 	if err != nil {
// 		if errors.Is(err, gorm.ErrRecordNotFound) {
// 			return nil, nil
// 		}
// 		return nil, err
// 	}

// 	if *tokenData.Expiry > time.Now().Unix() {
// 		return tokenData, nil
// 	}

// 	// 过期则删除 token
// 	m.DeleteToken(token)
// 	return nil, nil
// }

func (m *KillaraCustomerTokenModel) CheckToken(tokenstr string) (*KillaraCustomerToken, error) {
	var resultToken *KillaraCustomerToken
	err := m.db.Model(&KillaraCustomerToken{}).Transaction(func(tx *gorm.DB) error {
		// 查找 Token 记录
		var token KillaraCustomerToken
		err := tx.Where("token = ?", tokenstr).First(&token).Error
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return nil
			}
			tx.Rollback() // 发生错误,回滚事务
			return err
		}

		// 判断 Token 是否过期
		if *token.Expiry <= time.Now().Unix() {
			// 过期则删除 Token
			err = tx.Delete(&token).Error
			if err != nil {
				tx.Rollback() // 删除错误,回滚事务
				return err
			}
		}

		resultToken = &token
		return err // 提交事务
	})

	if err != nil {
		return nil, err
	}
	return resultToken, nil
}

func (m *KillaraCustomerTokenModel) ClearDuplicateToken(customerID uint64, currentToken string, platform int) error {

	return m.db.Model(&KillaraCustomerToken{}).Transaction(func(tx *gorm.DB) error {
		var tokens []*KillaraCustomerToken
		err := tx.Where("customer_id = ? AND platform = ?", customerID, platform).Find(&tokens).Error
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				log.Println("当前的token, 自身都不存在, 疑似出了什么错误1")
				return nil
			}
			tx.Rollback() // 发生错误,回滚事务
			return err
		}

		for _, token := range tokens {
			if *token.Token != currentToken {
				// err := tx.Delete(token).Error todo: 不太明白php为什么不删除token, 难道用来链路跟踪? 但是客户端id也被更新了, 没有存在的意义了
				err := tx.Where("token = ?", *token.Token).Update("customer_id", 0).Error
				if err != nil {
					if errors.Is(err, gorm.ErrRecordNotFound) {
						return fmt.Errorf("tokens 查询出来, 自身都不存在, 疑似出了什么错误2")
					}
					tx.Rollback() // 发生错误,回滚事务
					return err
				}
			}
		}

		return tx.Commit().Error
	})
}

func (m *KillaraCustomerTokenModel) GetTokenByCustomerID(customerID uint64) (*string, error) {
	var token KillaraCustomerToken
	err := m.db.Select("token").Where("customer_id = ?", customerID).First(&token).Error
	if errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, nil
	}
	return token.Token, err
}

func (m *KillaraCustomerTokenModel) GetTokenDataByCustomerID(customerID uint64) (map[string]interface{}, error) {
	var token KillaraCustomerToken
	err := m.db.Select("data").Where("customer_id = ?", customerID).First(&token).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}

	var data map[string]interface{}
	err = json.Unmarshal([]byte(*token.Data), &data)
	return data, err
}