package data_manage

import (
	"database/sql"
	"eta/eta_api/utils"
	"fmt"
	"time"

	"eta/eta_api/global"
)

// BaseFromClarksonsClassify 卓创红期原始数据分类表
type BaseFromClarksonsClassify struct {
	BaseFromClassifyId int       `gorm:"column:base_from_clarksons_classify_id;primaryKey"`
	ClassifyName       string    `description:"分类名称"`
	ParentId           int       `description:"父级id"`
	Level              int       `description:"层级"`
	Sort               int       `description:"排序字段"`
	ModifyTime         time.Time `description:"修改时间"`
	CreateTime         time.Time `description:"创建时间"`
}

type BaseFromClarksonsClassifyItem struct {
	BaseFromClassifyId int                              `gorm:"column:base_from_clarksons_classify_id;primaryKey"`
	ClassifyName       string                           `description:"分类名称"`
	ParentId           int                              `description:"父级id"`
	Level              int                              `description:"层级"`
	Sort               int                              `description:"排序字段"`
	UniqueCode         string                           `description:"唯一code"`
	ModifyTime         time.Time                        `description:"修改时间"`
	CreateTime         time.Time                        `description:"创建时间"`
	ClassifyNameEn     string                           `description:"英文分类名称"`
	Children           []*BaseFromClarksonsClassifyItem `description:"子分类" gorm:"-"`
}

type BaseFromClarksonsClassifyMaxSort struct {
	BaseFromClassifyId int `description:"分类id"`
	MaxSort            int `description:"最大排序"`
}

func (t *BaseFromClarksonsClassify) Add() (insertId int64, err error) {
	err = global.DbMap[utils.DbNameIndex].Create(t).Error
	return
}

func (t *BaseFromClarksonsClassify) Update(cols []string) (err error) {
	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(t).Error
	return
}

func BatchAddClarksonsClassify(items []*BaseFromClarksonsClassify) (err error) {
	err = global.DbMap[utils.DbNameIndex].CreateInBatches(items, len(items)).Error
	return
}

// 获取所有分类
func GetClarksonsClassifyAll() (items []*BaseFromClarksonsClassifyItem, err error) {
	sql := ` SELECT * FROM base_from_clarksons_classify ORDER BY sort ASC, base_from_clarksons_classify_id ASC`
	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
	return
}

// GetChildClarksonsClassifyListById 获取子分类列表
func GetChildClarksonsClassifyListById(classifyId int) (items []*BaseFromClarksonsClassifyItem, err error) {
	sql := ` SELECT * FROM base_from_clarksons_classify WHERE parent_id=? `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
	return
}

// GetChildClarksonsClassifyIdsById 获取子分类的id集合
func GetChildClarksonsClassifyIdsById(classifyId int) (items []int, err error) {
	sql := ` SELECT base_from_clarksons_classify_id FROM base_from_clarksons_classify WHERE parent_id=? `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
	return
}

// GetChildClarksonsClassifyMaxSortById 获取子分类最大排序
func GetChildClarksonsClassifyMaxSortById(classifyId int) (sort int, err error) {
	sqlStr := ` SELECT COALESCE(MAX(sort),0) AS sort FROM base_from_clarksons_classify WHERE parent_id=? `

	var totalNull sql.NullInt64
	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyId).Scan(&totalNull).Error
	if !totalNull.Valid {
		sort = 0
	} else {
		sort = int(totalNull.Int64)
	}
	return
}

// GetClarksonsClassifyCountById 获取分类数量
func GetClarksonsClassifyCountById(classifyId int) (count int, err error) {
	sqlStr := ` SELECT COUNT(*) AS count FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id=? `
	var totalNull sql.NullInt64
	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyId).Scan(&totalNull).Error
	if !totalNull.Valid {
		count = 0
	} else {
		count = int(totalNull.Int64)
	}
	return
}

// GetClarksonsClassifyById 通过分类id获取分类
func GetClarksonsClassifyById(classifyId int) (item *BaseFromClarksonsClassify, err error) {
	sql := ` SELECT * FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id=? `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).First(&item).Error
	return
}

// GetClarksonsChildClassifyById 通过分类id获取子分类
func GetClarksonsChildClassifyIdsById(classifyId int) (items []int, err error) {
	sql := ` SELECT base_from_clarksons_classify_id FROM base_from_clarksons_classify WHERE parent_id=? `
	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
	return
}

// GetClarksonsClassifyListByIds 通过分类id获取分类列表
func GetClarksonsClassifyListByIds(classifyIds []int) (items []*BaseFromClarksonsClassify, err error) {
	if len(classifyIds) == 0 {
		return
	}
	sql := ` SELECT * FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `)`
	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyIds).Find(&items).Error
	return
}

// GetClarksonsClassifyCountByName 通过分类名称获取分类
func GetClarksonsClassifyCountByName(classifyName string) (count int, err error) {
	sqlStr := ` SELECT COUNT(*) AS count FROM base_from_clarksons_classify WHERE 1=1`

	sqlStr += ` AND classify_name=? `

	var totalNull sql.NullInt64
	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyName).Scan(&count).Error
	if !totalNull.Valid {
		count = 0
	} else {
		count = int(totalNull.Int64)
	}
	return
}

func GetBaseFromClarksonsClassifyEnCount(classifyNameEn string, parentId int) (count int, err error) {
	sqlStr := `SELECT COUNT(1) AS count FROM base_from_clarksons_classify WHERE classify_name_en=? AND parent_id=? `
	var totalNull sql.NullInt64
	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyNameEn, parentId).Scan(&totalNull).Error
	if !totalNull.Valid {
		count = 0
	} else {
		count = int(totalNull.Int64)
	}
	return
}

func GetBaseFromClarksonsClassifyCount(classifyName string, parentId int) (count int, err error) {
	sqlStr := `SELECT COUNT(1) AS count FROM base_from_clarksons_classify WHERE classify_name=? AND parent_id=? `
	var totalNull sql.NullInt64
	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyName, parentId).Scan(&count).Error
	if !totalNull.Valid {
		count = 0
	} else {
		count = int(totalNull.Int64)
	}
	return
}

func DeleteClarksonsClassifyById(classifyId int) (err error) {
	sql := ` DELETE FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id=? `
	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyId).Error
	return
}

// BatchDeleteClarksonsClassifyById 批量删除分类
func BatchDeleteClarksonsClassifyById(classifyId []int) (err error) {
	if len(classifyId) == 0 {
		return
	}

	tx := global.DbMap[utils.DbNameIndex].Begin()
	defer func() {
		if err != nil {
			_ = tx.Rollback()
		} else {
			_ = tx.Commit()
		}
	}()

	sql := ` DELETE FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id IN (` + utils.GetOrmInReplace(len(classifyId)) + `) `
	err = tx.Exec(sql, classifyId).Error
	return
}

// DeleteClarksonsClassifyByClassifyId 根据分类id删除对应的指标分类
func DeleteClarksonsClassifyByClassifyId(classifyIdList []int) (err error) {
	num := len(classifyIdList)
	if num <= 0 {
		return
	}
	//删除分类
	sql := `DELETE FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id IN (` + utils.GetOrmInReplace(num) + `) `
	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyIdList).Error
	return
}

// GetClarksonsIndexClassifyMinSort 获取最小不等于0的排序
func GetClarksonsIndexClassifyMinSort(parentId int) (sort int, err error) {
	sqlStr := `SELECT MIN(sort) FROM base_from_clarksons_classify WHERE parent_id=? AND sort <> 0 `
	var totalNull sql.NullInt64
	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, parentId).Scan(&totalNull).Error
	if !totalNull.Valid {
		sort = 0
	} else {
		sort = int(totalNull.Int64)
	}
	return
}

// MoveUpClarksonsIndexClassifyBySort 往上移动
func MoveUpClarksonsIndexClassifyBySort(parentId, nextSort, currentSort int) (err error) {
	sql := `update base_from_clarksons_classify set sort = sort + 1 where parent_id=? and sort >= ? and sort< ?`
	err = global.DbMap[utils.DbNameIndex].Exec(sql, parentId, nextSort, currentSort).Error
	return
}

// MoveDownClarksonsIndexClassifyBySort 往下移动
func MoveDownClarksonsIndexClassifyBySort(parentId, prevSort, currentSort int) (err error) {
	sql := `update base_from_clarksons_classify set sort = sort - 1 where parent_id=? and sort <= ? and sort> ? `
	err = global.DbMap[utils.DbNameIndex].Exec(sql, parentId, prevSort, currentSort).Error
	return
}

// UpdateClarksonsClassifySortByParentId 根据父类id更新排序
func UpdateClarksonsClassifySortByParentId(parentId, classifyId, nowSort int, updateSort string) (err error) {
	sql := ` update base_from_clarksons_classify set sort = ` + updateSort + ` WHERE parent_id=? and sort > ? `
	if classifyId > 0 {
		sql += ` or ( base_from_clarksons_classify_id > ` + fmt.Sprint(classifyId) + ` and sort= ` + fmt.Sprint(nowSort) + `)`
	}
	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId, nowSort).Error
	return
}

// GetFirstClarksonsClassifyByParentId 获取当前父级分类下的排序第一条的数据
func GetFirstClarksonsClassifyByParentId(parentId int) (item *ChartClassify, err error) {
	sql := ` SELECT * FROM base_from_clarksons_classify WHERE parent_id=? order by sort asc,base_from_clarksons_classify_id asc limit 1`
	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId).First(&item).Error
	return
}