package service

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

	"github.com/bytedance/sonic"
	"github.com/go-admin-team/go-admin-core/sdk/service"
	"gorm.io/gorm"

	"go-admin/app/admin/models"
	"go-admin/app/admin/service/dto"
	"go-admin/common/actions"
	cDto "go-admin/common/dto"
	"go-admin/common/rediskey"
	helper "go-admin/utils/redishelper"
)

type WmToken struct {
	service.Service
}

// GetPage 获取WmToken列表
func (e *WmToken) GetPage(c *dto.WmTokenGetPageReq, p *actions.DataPermission, list *[]models.WmToken, count *int64) error {
	var err error
	var data models.WmToken
	query := e.Orm.Model(&data).
		Scopes(
			cDto.MakeCondition(c.GetNeedSearch()),
			cDto.Paginate(c.GetPageSize(), c.GetPageIndex()),
			actions.Permission(data.TableName(), p),
		)

	if c.TransType > 0 {
		query.Where("trans_type = ?", c.TransType)
	}

	err = query.
		Find(list).Limit(-1).Offset(-1).
		Count(count).Error
	if err != nil {
		e.Log.Errorf("WmTokenService GetPage error:%s \r\n", err)
		return err
	}
	return nil
}

// Get 获取WmToken对象
func (e *WmToken) Get(d *dto.WmTokenGetReq, p *actions.DataPermission, model *models.WmToken) error {
	var data models.WmToken

	err := e.Orm.Model(&data).
		Scopes(
			actions.Permission(data.TableName(), p),
		).
		First(model, d.GetId()).Error
	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
		err = errors.New("查看对象不存在或无权查看")
		e.Log.Errorf("Service GetWmToken error:%s \r\n", err)
		return err
	}
	if err != nil {
		e.Log.Errorf("db error:%s", err)
		return err
	}
	return nil
}

// Insert 创建WmToken对象
func (e *WmToken) Insert(c *dto.WmTokenInsertReq) error {
	var err error
	var data models.WmToken
	c.Generate(&data)
	err = e.Orm.Create(&data).Error
	if err != nil {
		e.Log.Errorf("WmTokenService Insert error:%s \r\n", err)
		return err
	}

	e.ReCache("")
	return nil
}

// Update 修改WmToken对象
func (e *WmToken) Update(c *dto.WmTokenUpdateReq, p *actions.DataPermission) error {
	var err error
	var data = models.WmToken{}
	e.Orm.Scopes(
		actions.Permission(data.TableName(), p),
	).First(&data, c.GetId())
	c.Generate(&data)

	db := e.Orm.Save(&data)
	if err = db.Error; err != nil {
		e.Log.Errorf("WmTokenService Save error:%s \r\n", err)
		return err
	}
	if db.RowsAffected == 0 {
		return errors.New("无权更新该数据")
	}
	e.ReCache("")
	return nil
}

// Remove 删除WmToken
func (e *WmToken) Remove(d *dto.WmTokenDeleteReq, p *actions.DataPermission) error {
	var data models.WmToken

	db := e.Orm.Model(&data).
		Scopes(
			actions.Permission(data.TableName(), p),
		).Delete(&data, d.GetId())
	if err := db.Error; err != nil {
		e.Log.Errorf("Service RemoveWmToken error:%s \r\n", err)
		return err
	}
	if db.RowsAffected == 0 {
		return errors.New("无权删除该数据")
	}

	e.ReCache("")
	return nil
}

// 重置代币缓存
// networkCode 网络code(如果为空则重置所有网络的缓存)
func (e *WmToken) ReCache(networkCode string) error {
	var datas []models.WmToken
	mapData := make(map[int][]string)
	query := e.Orm.Model(&models.WmToken{})

	if networkCode != "" {
		query.Where("network_id = ?", networkCode)
	}

	if err := query.Find(&datas).Error; err != nil {
		e.Log.Errorf("Service ReCache error:%s \r\n", err)
		return err
	}

	for _, v := range datas {
		contentByte, _ := json.Marshal(v)

		if len(contentByte) > 0 {
			mapData[v.NetworkId] = append(mapData[v.NetworkId], string(contentByte))
		}
	}

	for k, v := range mapData {
		key := fmt.Sprintf(rediskey.Tokens, k)

		if err := helper.DefaultRedis.SetListCache(key, 0, v...); err != nil {
			e.Log.Errorf("Service ReCache key:%s error:%s \r\n", key, err)
		}
	}

	return nil
}

// GetAll 获取所有代币信息
func (e *WmToken) GetAll() ([]models.WmToken, error) {
	result := make([]models.WmToken, 0)
	data := models.WmToken{}
	keys, _ := helper.DefaultRedis.ScanKeys(fmt.Sprintf(rediskey.Tokens, "*"))

	if keys == nil || len(keys) == 0 {
		if err := e.Orm.Model(data).Find(&result).Error; err != nil {
			e.Log.Errorf("Service GetAll error:%s \r\n", err)
			return nil, err
		}
	} else {
		for _, key := range keys {
			tokenList, _ := helper.DefaultRedis.GetAllList(key)

			for _, token := range tokenList {
				sonic.UnmarshalString(token, &data)

				if data.Id > 0 {
					result = append(result, data)
				}
			}
		}
	}

	return result, nil
}

// GetByTokenId 根据networkId和tokenAddress获取代币信息
func (e *WmToken) GetByTokenId(networkId int, tokenAddress string) (models.WmToken, error) {
	key := fmt.Sprintf(rediskey.Tokens, networkId)
	token := models.WmToken{}
	tokens, _ := helper.DefaultRedis.GetAllList(key)

	for _, v := range tokens {
		var data models.WmToken
		_ = json.Unmarshal([]byte(v), &data)
		if data.TokenAddress == tokenAddress {
			token = data
			return token, nil
		}
	}

	if token.Id == 0 {
		if err := e.Orm.Model(&models.WmToken{}).Where("network_id = ? and token_address = ?", networkId, tokenAddress).First(&token).Error; err != nil {
			e.Log.Errorf("Service GetByTokenId error:%s \r\n", err)
			return models.WmToken{}, err
		}
	}

	return token, nil
}

// GetAutoTransTokens 获取自动转账的代币列表
func (e WmToken) GetAutoTransTokens(netowrkIds []int) ([]models.WmToken, error) {
	tokens := make([]models.WmToken, 0)

	for _, networkId := range netowrkIds {
		key := fmt.Sprintf(rediskey.Tokens, networkId)
		tokensList, _ := helper.DefaultRedis.GetAllList(key)

		for _, v := range tokensList {
			var data models.WmToken
			_ = json.Unmarshal([]byte(v), &data)
			if data.IsAuto == 1 {
				tokens = append(tokens, data)
			}
		}
	}

	if len(tokens) == 0 {
		if err := e.Orm.Model(&models.WmToken{}).Where("network_id in (?) and is_auto = ?", netowrkIds, 1).Find(&tokens).Error; err != nil {
			e.Log.Errorf("Service GetAutoTransTokens error:%s \r\n", err)
			return nil, err
		}
	}

	return tokens, nil
}