package data_manage

import (
	"eta/eta_api/global"
	"eta/eta_api/utils"
	"fmt"

	"github.com/rdlucklib/rdluck_tools/paging"
	"gorm.io/gorm"
)

type GlClassify struct {
	BreedShortName string `gorm:"column:BREED_SHORT_NAME" description:"分类名称"`
}

func GetGlSurveyClassify() (items []*GlClassify, err error) {
	sql := `SELECT CASE WHEN BREED_SHORT_NAME IS NULL THEN '无' ELSE BREED_SHORT_NAME END BREED_SHORT_NAME 
           FROM mb_index_main_info GROUP BY BREED_SHORT_NAME ORDER BY BREED_SHORT_NAME ASC`
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql).Find(&items).Error
	return
}

type GlFrequency struct {
	Frequency string `description:"频度:1-日度 2-周度 3-月度 4-季度 5-年度 99-无固定频率"`
}

func GetGlFrequencyByClassifyId(breedShortName string) (items []*GlFrequency, err error) {
	o := global.DbMap[utils.DbNameGL]
	var sql string
	if breedShortName == "无" {
		sql = `SELECT FREQUENCY_NAME AS frequency FROM mb_index_main_info 
               WHERE BREED_SHORT_NAME IS NULL GROUP BY FREQUENCY_CODE ORDER BY FREQUENCY_CODE ASC`
		err = o.Raw(sql).Find(&items).Error
	} else {
		sql = `SELECT FREQUENCY_NAME AS frequency FROM mb_index_main_info 
               WHERE BREED_SHORT_NAME=? GROUP BY FREQUENCY_CODE ORDER BY FREQUENCY_CODE ASC`
		err = o.Raw(sql, breedShortName).Find(&items).Error
	}
	return
}

type GlIndex struct {
	Id            int    `gorm:"column:id;primaryKey"`
	IndexCode     string `description:"指标编码" gorm:"column:INDEX_CODE"`
	IndexName     string `description:"指标名称" gorm:"column:INDEX_NAME"`
	UnitName      string `description:"单位" gorm:"column:UNIT_NAME"`
	FrequencyName string `description:"频度名称" gorm:"column:FREQUENCY_NAME"`
	UpdateTime    string `description:"更新时间" gorm:"column:UPDATE_TIME"`
}

func (g *GlIndex) AfterFind(tx *gorm.DB) (err error) {
	g.UpdateTime = utils.GormDateStrToDateTimeStr(g.UpdateTime)
	return
}
func (g *GlIndex) TimeToDateStr() {
	g.UpdateTime = utils.GormDateStrToDateTimeStr(g.UpdateTime)
	return
}

func GetGlIndex(breedShortName, frequency string) (items []*GlIndex, err error) {
	o := global.DbMap[utils.DbNameGL]
	var sql string
	if breedShortName == "无" {
		sql = `SELECT * FROM mb_index_main_info 
               WHERE BREED_SHORT_NAME IS NULL AND FREQUENCY_NAME=? ORDER BY INDEX_CODE ASC`
		err = o.Raw(sql, frequency).Find(&items).Error
	} else {
		sql = `SELECT * FROM mb_index_main_info 
               WHERE BREED_SHORT_NAME=? AND FREQUENCY_NAME=? ORDER BY INDEX_CODE ASC`
		err = o.Raw(sql, breedShortName, frequency).Find(&items).Error
	}
	return
}

func GetGlFrequency(productName string) (items []*string, err error) {
	sql := `SELECT DISTINCT FREQUENCY_NAME FROM mb_index_main_info 
           WHERE BREED_SHORT_NAME=? ORDER BY FIELD(FREQUENCY_NAME,'日度','周度','旬度','月度','季度','半年','年度')`
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql, productName).Find(&items).Error
	return
}

type GlIndexList struct {
	Id            int                `gorm:"column:ID;primaryKey"`
	IndexCode     string             `gorm:"column:INDEX_CODE" description:"指标编码"`
	IndexName     string             `gorm:"column:INDEX_NAME" description:"指标名称"`
	UnitName      string             `gorm:"column:UNIT_NAME" description:"单位"`
	FrequencyName string             `gorm:"column:FREQUENCY_NAME" description:"频度名称"`
	UpdateTime    string             `gorm:"column:UPDATE_TIME" description:"更新时间"`
	Paging        *paging.PagingItem `gorm:"-" description:"分页数据"`
	DataList      []*GlIndexData     `gorm:"-"`
}

type GlIndexData struct {
	InputValue string `description:"日期" gorm:"column:DATA_VALUE"`
	DataTime   string `description:"值" gorm:"column:DATA_DATE"`
}

func (g *GlIndexData) AfterFind(tx *gorm.DB) (err error) {
	g.InputValue = utils.GormDateStrToDateStr(g.InputValue)
	return
}

func GetGlIndexData(indexCode string, startSize, pageSize int) (items []*GlIndexData, err error) {
	sql := `SELECT * FROM (
		SELECT DISTINCT a.INDEX_CODE,a.DATA_VALUE,a.DATA_DATE FROM mb_index_main_data AS a 
		WHERE INDEX_CODE=? AND IS_DELETE=0
		ORDER BY DATA_DATE DESC,PUBLISH_TIME DESC 
	) AS t
	GROUP BY t.DATA_DATE
	ORDER BY t.DATA_DATE DESC LIMIT ?,?`
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql, indexCode, startSize, pageSize).Find(&items).Error
	return
}

func GetGlIndexByCode(indexCode string) (items *GlIndex, err error) {
	sql := `SELECT * FROM mb_index_main_info WHERE INDEX_CODE=?`
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql, indexCode).First(&items).Error
	if err != nil {
		return
	}
	items.TimeToDateStr()
	return
}

func GetGlIndexDataCount(indexCode string) (count int, err error) {
	sql := `SELECT COUNT(1) AS count FROM (
		SELECT * FROM (
			SELECT DISTINCT a.INDEX_CODE,a.DATA_VALUE,a.DATA_DATE FROM mb_index_main_data AS a 
			WHERE INDEX_CODE=? AND IS_DELETE=0
			ORDER BY DATA_DATE DESC,PUBLISH_TIME DESC 
		) AS t
		GROUP BY t.DATA_DATE
		ORDER BY t.DATA_DATE DESC
	) AS n`
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql, indexCode).Scan(&count).Error
	return
}

type GlSearchIndex struct {
	Id             int     `orm:"column(ID)" gorm:"column:ID"`
	IndexCode      string  `orm:"column(INDEX_CODE)" gorm:"column:INDEX_CODE"`
	IndexName      string  `orm:"column(INDEX_NAME)" gorm:"column:INDEX_NAME"`
	UnitName       string  `orm:"column(UNIT_NAME)" gorm:"column:UNIT_NAME"`
	FrequencyName  string  `orm:"column(FREQUENCY_NAME)" gorm:"column:FREQUENCY_NAME"`
	UpdateTime     string  `orm:"column(UPDATE_TIME)" gorm:"column:UPDATE_TIME"`
	BreedShortName string  `orm:"column(BREED_SHORT_NAME)" gorm:"column:BREED_SHORT_NAME"`
	StartDate      string  `orm:"column(BEGIN_DATE)" gorm:"column:BEGIN_DATE"`
	EndDate        string  `orm:"column(END_DATE)" gorm:"column:END_DATE"`
	LatestValue    float64 `orm:"column(DATA_VALUE)" gorm:"column:DATA_VALUE"`
	CreateTime     string  `orm:"column(CREATE_TIME)" gorm:"column:CREATE_TIME"`
	ModifyTime     string  `orm:"column(UPDATE_TIME)" gorm:"column:UPDATE_TIME"`
	Source         int     `gorm:"-"`
	SourceName     string  `orm:"column(SOURCE_NAME)" gorm:"column:SOURCE_NAME"`
	SearchText     string  `description:"搜索结果（含高亮）" gorm:"-"`
}

func (g *GlSearchIndex) AfterFind(tx *gorm.DB) (err error) {
	g.UpdateTime = utils.GormDateStrToDateTimeStr(g.UpdateTime)
	g.CreateTime = utils.GormDateStrToDateTimeStr(g.CreateTime)
	g.ModifyTime = utils.GormDateStrToDateTimeStr(g.ModifyTime)
	g.StartDate = utils.GormDateStrToDateStr(g.StartDate)
	g.EndDate = utils.GormDateStrToDateStr(g.EndDate)
	return
}

func GetGlItemList(keyword string) (items []*GlSearchIndex, err error) {
	sql := "SELECT * FROM mb_index_main_info WHERE CONCAT(INDEX_NAME,INDEX_CODE) LIKE ?"
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql, utils.GetLikeKeyword(keyword)).Find(&items).Error
	return
}

func GetGlDataMaxCount(classifyName string) (count int, err error) {
	sql := `SELECT MAX(t.num) AS count FROM (
		SELECT COUNT(1) AS num FROM mb_index_main_info AS a
		INNER JOIN mb_index_main_data AS b ON a.INDEX_CODE=b.INDEX_CODE
		WHERE a.BREED_SHORT_NAME=?
		GROUP BY a.INDEX_CODE
	) AS t`
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql, classifyName).Scan(&count).Error
	return
}

func GetGlDataByCode(indexCode string) (items []*GlIndexData, err error) {
	//sql := `SELECT * FROM (
	//	SELECT * FROM mb_index_main_data WHERE INDEX_CODE=?
	//	GROUP BY UPDATE_TIME DESC, DATA_DATE DESC
	//) a GROUP BY a.DATA_DATE DESC`
	sql := `SELECT * FROM (
		SELECT * FROM mb_index_main_data WHERE INDEX_CODE=? 
		GROUP BY UPDATE_TIME , DATA_DATE  ORDER BY UPDATE_TIME DESC, DATA_DATE DESC
	) a GROUP BY a.DATA_DATE ORDER BY a.DATA_DATE DESC`
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql, indexCode).Find(&items).Error
	return
}

type GlDataPageListResp struct {
	Paging *paging.PagingItem
	List   []*GlSearchIndex
}

func GetGlItemListByIds(ids []int) (items []*GlSearchIndex, err error) {
	if len(ids) == 0 {
		return
	}
	sql := fmt.Sprintf(`SELECT * FROM mb_index_main_info WHERE ID IN (%s)`, utils.GetOrmInReplace(len(ids)))
	o := global.DbMap[utils.DbNameGL]
	err = o.Raw(sql, ids).Find(&items).Error
	return
}