package models

import (
	"errors"
	orm "go-admin/common/global"
	"go-admin/logger"
)

// HomeCategory 首页分类表结构体
type HomeCategory struct {
	Model

	Name      string         `json:"name" gorm:"index"`       // 分类名称
	SortOrder uint32         `json:"sort_order" gorm:"index"` // 排序序号
	State     uint32         `json:"state" gorm:"index"`      // 状态：1-启用；2-隐藏
	AllFlag   uint32         `json:"all_flag"`                // 是否包含所有游戏：0-不包含；1-包含
	OrderFlag uint32         `json:"order_flag"`              // 是否根据销量排序：0-不选择；1-根据租赁数量排序
	Games     []HomeGameList `json:"games" gorm:"-"`          // 关联的游戏
}

// HomeGameList 首页分类归属游戏
type HomeGameList struct {
	GameID    uint32 `json:"game_id"`    // 游戏ID
	SortOrder uint32 `json:"sort_order"` // 排序序号
	GameName  string `json:"game_name"`  // 游戏名称
}

// HomeCategoryGame 分类与游戏关联表结构体
type HomeCategoryGame struct {
	Model

	HomeCategoryID uint32 `json:"home_category_id" gorm:"index"` // 首页分类ID，外键关联 HomeCategory
	GameID         uint32 `json:"game_id"  gorm:"index"`         // 游戏ID，外键关联 GameCard
	GameName       string `json:"game_name"`                     // 游戏名称
	SortOrder      int    `json:"sort_order"  gorm:"index"`      // 归属游戏中排序序号
}

// HomeCategoryListReq 首页分类列表入参
type HomeCategoryListReq struct {
	Name      string `json:"name"`      // 优惠券名称
	State     uint32 `json:"state"`     // 状态：1-启用；2-隐藏
	PageIndex int    `json:"pageIndex"` // 页码
	PageSize  int    `json:"pageSize"`  // 页面条数
}

// HomeCategoryListResp 首页分类列表出参
type HomeCategoryListResp struct {
	List      []HomeCategory `json:"list"`
	Total     int            `json:"total"`     // 总条数
	PageIndex int            `json:"pageIndex"` // 页码
	PageSize  int            `json:"pageSize"`  // 页面条数
}

// List 查询采购订单列表
func (m *HomeCategoryListReq) List() (*HomeCategoryListResp, error) {
	resp := &HomeCategoryListResp{
		PageIndex: m.PageIndex,
		PageSize:  m.PageSize,
	}
	page := m.PageIndex - 1
	if page < 0 {
		page = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}
	qs := orm.Eloquent.Table("home_category")

	if m.Name != "" {
		qs = qs.Where("name=?", m.Name)
	}
	if m.State != 0 {
		qs = qs.Where("state=?", m.State)
	}

	var count int64
	err := qs.Count(&count).Error
	if err != nil {
		logger.Error("count err:", logger.Field("err", err))
		return resp, err
	}

	resp.Total = int(count)
	var orders []HomeCategory
	err = qs.Order("sort_order ASC").Offset(page * m.PageSize).Limit(m.PageSize).Find(&orders).Error
	if err != nil && err != RecordNotFound {
		logger.Error("home_category list err:", logger.Field("err", err))
		return resp, err
	}

	// 组合关联的游戏数据
	for i := range orders {
		var games []HomeCategoryGame
		err = orm.Eloquent.Table("home_category_game").Where("home_category_id = ?", orders[i].ID).
			Order("sort_order ASC").Find(&games).Error
		if err != nil {
			logger.Error("home_category_game list err:", logger.Field("err", err))
			return resp, err
		}

		// 将 HomeCategoryGame 转换为 HomeGameList
		for _, game := range games {
			orders[i].Games = append(orders[i].Games, HomeGameList{
				GameID:    game.GameID,
				SortOrder: uint32(game.SortOrder),
				GameName:  game.GameName,
			})
		}
	}

	resp.List = orders
	return resp, nil
}

// HomeCategoryAddReq 新增首页分类入参
type HomeCategoryAddReq struct {
	Name      string         `json:"name" validate:"required"`       // 分类名称
	SortOrder uint32         `json:"sort_order" validate:"required"` // 排序序号
	AllFlag   uint32         `json:"all_flag"`                       // 是否包含所有游戏：0-不包含；1-包含
	OrderFlag uint32         `json:"order_flag"`                     // 是否根据销量排序：0-不选择；1-根据租赁数量排序
	State     uint32         `json:"state" validate:"required"`      // 状态：1-启用；2-隐藏
	Games     []HomeGameList `json:"games"`                          // 关联的游戏
}

// CreateHomeCategory 新增分类
func CreateHomeCategory(req *HomeCategoryAddReq) error {
	// 初始化首页分类数据
	newHomeCategory := &HomeCategory{
		Name:      req.Name,
		SortOrder: req.SortOrder,
		State:     req.State,
		AllFlag:   req.AllFlag,
		OrderFlag: req.OrderFlag,
	}

	// 开启事务
	tx := orm.Eloquent.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 插入首页分类记录
	err := tx.Create(newHomeCategory).Error
	if err != nil {
		logger.Error("create home category err:", logger.Field("err", err))
		tx.Rollback()
		return err
	}

	// 如果 Games 不为空，插入分类与游戏关联记录
	if len(req.Games) > 0 {
		var homeCategoryGames []HomeCategoryGame
		for _, game := range req.Games {
			homeCategoryGames = append(homeCategoryGames, HomeCategoryGame{
				HomeCategoryID: newHomeCategory.ID,
				GameID:         game.GameID,
				SortOrder:      int(game.SortOrder),
				GameName:       game.GameName,
			})
		}

		// 批量插入关联记录
		err = tx.Create(&homeCategoryGames).Error
		if err != nil {
			logger.Error("create home category games err:", logger.Field("err", err))
			tx.Rollback()
			return err
		}
	}

	// 提交事务
	err = tx.Commit().Error
	if err != nil {
		logger.Error("commit transaction err:", logger.Field("err", err))
		return err
	}

	return nil
}

// HomeCategoryDeleteReq 首页分类删除-入参
type HomeCategoryDeleteReq struct {
	HomeCategoryID uint32 `json:"home_category_id" validate:"required"` // 首页分类id
}

// DeleteHomeCategory 删除首页分类
func DeleteHomeCategory(req *HomeCategoryDeleteReq) error {
	// 开始事务
	tx := orm.Eloquent.Begin()

	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
			panic(r)
		}
	}()

	var categoryInfo HomeCategory

	// 查询首页分类信息
	err := tx.Table("home_category").Where("id = ?", req.HomeCategoryID).Find(&categoryInfo).Error
	if err != nil {
		logger.Error("home_category delete err:", logger.Field("err", err))
		tx.Rollback()
		return errors.New("未查询到分类")
	}

	// 删除关联的 HomeCategoryGame 数据
	err = tx.Table("home_category_game").Where("home_category_id = ?", req.HomeCategoryID).Delete(&HomeCategoryGame{}).Error
	if err != nil {
		logger.Error("home_category_game delete err:", logger.Field("err", err))
		tx.Rollback()
		return errors.New("删除分类关联游戏失败")
	}

	// 删除首页分类数据
	err = tx.Delete(&categoryInfo).Error
	if err != nil {
		logger.Error("home_category delete2 err:", logger.Field("err", err))
		tx.Rollback()
		return err
	}

	// 提交事务
	err = tx.Commit().Error
	if err != nil {
		logger.Error("transaction commit err:", logger.Field("err", err))
		return errors.New("事务提交失败")
	}

	return nil
}

// HomeCategoryEditReq 编辑首页分类-入参
type HomeCategoryEditReq struct {
	HomeCategoryID uint32         `json:"home_category_id" validate:"required"` // 首页分类id
	Name           string         `json:"name" validate:"required"`             // 分类名称
	SortOrder      uint32         `json:"sort_order" validate:"required"`       // 排序序号
	State          uint32         `json:"state" validate:"required"`            // 状态：1-启用；2-隐藏
	AllFlag        uint32         `json:"all_flag"`                             // 是否包含所有游戏：0-不包含；1-包含
	OrderFlag      uint32         `json:"order_flag"`                           // 是否根据销量排序：0-不选择；1-根据租赁数量排序
	Games          []HomeGameList `json:"games"`                                // 关联的游戏
}

// EditHomeCategory 编辑首页分类
func EditHomeCategory(req *HomeCategoryEditReq) (*HomeCategory, error) {
	// 查询分类信息
	var homeCategory HomeCategory
	err := orm.Eloquent.Table("home_category").Where("id = ?", req.HomeCategoryID).Find(&homeCategory).Error
	if err != nil {
		logger.Error("home_category err:", logger.Field("err", err))
		return nil, err
	}

	// 更新分类信息
	homeCategory.Name = req.Name
	homeCategory.SortOrder = req.SortOrder
	homeCategory.State = req.State
	homeCategory.AllFlag = req.AllFlag
	homeCategory.OrderFlag = req.OrderFlag
	err = orm.Eloquent.Table("home_category").Save(&homeCategory).Error
	if err != nil {
		logger.Error("update home_category err:", logger.Field("err", err))
		return nil, err
	}

	// 删除旧的 HomeCategoryGame 数据
	err = orm.Eloquent.Table("home_category_game").Where("home_category_id = ?", homeCategory.ID).Delete(&HomeCategoryGame{}).Error
	if err != nil {
		logger.Error("delete home_category_game err:", logger.Field("err", err))
		return nil, err
	}

	// 插入新的 HomeCategoryGame 数据
	var newGames []HomeCategoryGame
	for _, game := range req.Games {
		newGames = append(newGames, HomeCategoryGame{
			HomeCategoryID: homeCategory.ID,
			GameID:         game.GameID,
			GameName:       game.GameName,
			SortOrder:      int(game.SortOrder),
		})
	}

	if len(newGames) > 0 {
		err = orm.Eloquent.Table("home_category_game").Create(&newGames).Error
		if err != nil {
			logger.Error("insert home_category_game err:", logger.Field("err", err))
			return nil, err
		}
	}

	// 将 HomeCategoryGame 转换为 HomeGameList
	var gameList []HomeGameList
	for _, game := range newGames {
		gameList = append(gameList, HomeGameList{
			GameID:    game.GameID,
			SortOrder: uint32(game.SortOrder),
			GameName:  game.GameName,
		})
	}

	homeCategory.Games = gameList

	return &homeCategory, nil
}
