package data_manage

import (
	"eta/eta_api/global"
	"eta/eta_api/utils"
	"fmt"
	"gorm.io/gorm"
	"time"
)

// EdbTerminal 指标终端
type EdbTerminal struct {
	TerminalId   int       `orm:"column(terminal_id);pk" gorm:"primaryKey"`
	Source       int       `orm:"column(source)" description:"指标来源类型"`
	Name         string    `description:"终端名称"`
	TerminalCode string    `description:"终端编码，用于配置在机器上"`
	ServerUrl    string    `description:"终端地址"`
	DirPath      string    `description:"终端存放的文件夹路径"`
	Num          int       `description:"终端最大指标数"`
	Status       int       `description:"状态，1启用，2禁用"`
	Value        string    `description:"终端相关的token"`
	ModifyTime   time.Time `description:"修改时间"`
	CreateTime   time.Time `description:"创建时间"`
}

type EdbTerminalItem struct {
	TerminalId   int    `orm:"column(terminal_id);pk" gorm:"primaryKey"`
	Source       int    `description:"指标来源类型"`
	Name         string `description:"终端别名"`
	TerminalCode string `description:"终端编码，用于配置在机器上"`
	ServerUrl    string `description:"终端地址"`
	DirPath      string `description:"终端存放的文件夹路径"`
	Num          int    `description:"终端最大指标数"`
	Status       int    `description:"状态，1启用，2禁用"`
	Value        string `description:"终端相关的token"`
	ModifyTime   string `description:"修改时间"`
	CreateTime   string `description:"创建时间"`
}

func (e *EdbTerminalItem) AfterFind(db *gorm.DB) (err error) {
	e.ModifyTime = utils.GormDateStrToDateTimeStr(e.ModifyTime)
	e.CreateTime = utils.GormDateStrToDateTimeStr(e.CreateTime)
	return
}

type EdbTerminalCode struct {
	TerminalCode string `description:"终端编码，用于配置在机器上"`
	Source       int    `description:"指标来源类型"`
	Name         string `description:"终端别名"`
}

// GetEdbTerminalListBySource 根据指标来源类型获取所有的终端列表
func GetEdbTerminalListBySource(source int) (items []*EdbTerminal, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT *  FROM edb_terminal WHERE source = ? and status=1 ORDER BY terminal_id ASC `
	err = o.Raw(sql, source).Find(&items).Error
	return
}

type BaseIndexTerminalCode struct {
	TerminalCode string `description:"终端编码，用于配置在机器上"`
	IndexName    string
}

type EdbTerminalListResp struct {
	List []*EdbTerminalItem `description:"列表数据"`
}

type EdbTerminalCodeResp struct {
	List []*EdbTerminalCode `description:"终端编码列表"`
}

type AddEdbTerminalListReq struct {
	TerminalId int    `description:"终端id"`
	Source     int    `description:"指标来源类型"`
	Name       string `description:"终端别名"`
	//TerminalCode string `description:"终端编码，用于配置在机器上"`
	ServerUrl string `description:"终端地址"`
	DirPath   string `description:"终端存放的文件夹路径"`
	Num       int    `description:"终端最大指标数"`
	//Status    int    `description:"状态，1启用，2禁用"`
	Value string `description:"终端相关的token"`
}

type SetEdbTerminalStatusReq struct {
	TerminalId int `description:"终端id"`
	Status     int `description:"状态，1启用，2禁用"`
}

// GetBaseIndexTerminalCode 获取数据源的终端code
func GetBaseIndexTerminalCode(edbCode, tableName string) (item BaseIndexTerminalCode, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`select terminal_code, index_name from %s where index_code = ? `, tableName)
	err = o.Raw(sql, edbCode).First(&item).Error
	return
}

// GetEdbTerminalById 主键获取终端
func GetEdbTerminalById(id int) (item *EdbTerminal, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM edb_terminal WHERE terminal_id = ? LIMIT 1`
	err = o.Raw(sql, id).First(&item).Error
	return
}

func GetEdbTerminalByTerminalCode(terminalCode string) (item *EdbTerminal, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM edb_terminal WHERE terminal_code = ? LIMIT 1`
	err = o.Raw(sql, terminalCode).First(&item).Error
	return
}

func GetEdbTerminalList() (item []*EdbTerminalItem, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT * FROM edb_terminal ORDER BY terminal_id ASC`
	err = o.Raw(sql).Find(&item).Error
	return
}

func GetEdbTerminalBySource(source int) (item []*EdbTerminalItem, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT * FROM edb_terminal where source=? ORDER BY terminal_id ASC`
	err = o.Raw(sql, source).Find(&item).Error
	return
}

func (item *EdbTerminal) Add() (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Create(item).Error
	return
}

func (item *EdbTerminal) Update(cols []string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Model(item).Select(cols).Updates(item).Error
	return
}

// GetEdbTerminalByCode 根据终端编码获取终端信息
func GetEdbTerminalByCode(terminalCode string) (item *EdbTerminal, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := ` SELECT *  FROM edb_terminal WHERE terminal_code = ? `
	err = o.Raw(sql, terminalCode).First(&item).Error
	return
}

type TerminalCodeCountGroup struct {
	TerminalCode string
	Total        int
}

// GetEdbCountGroupByTerminal 获取终端code分组总数
func GetEdbCountGroupByTerminal(source int) (list []TerminalCodeCountGroup, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `select terminal_code,count(1) total from edb_info where source = ? AND no_update=0 AND terminal_code != "" group by terminal_code; `
	err = o.Raw(sql, source).Find(&list).Error
	return
}

// EdbTerminalDirInfo 指标终端文件夹信息
type EdbTerminalDirInfo struct {
	Name         string `description:"终端名称"`
	TerminalCode string `description:"终端编码，用于配置在机器上"`
	DirPath      string `description:"终端存放的文件夹路径"`
	FilePath     string `description:"文件夹路径"`
}

type EdbInfoTerminalList struct {
	EdbInfoId    int    `gorm:"column:edb_info_id"`
	EdbCode  string `gorm:"column:edb_code"`
	EdbName  string `gorm:"column:edb_name"`
	TerminalCode string `gorm:"column:terminal_code"`
	TerminalName string `gorm:"column:terminal_name"`
}

func GetSimpleEdbListPageByCondition(condition string, pars []interface{}, pageIndex int, pageSize int) (list []*EdbInfoTerminalList, err error) {
	sql := `SELECT e.*, t.name as terminal_name FROM edb_info e left join edb_terminal t on e.terminal_code = t.terminal_code WHERE 1=1 ` + condition + ` ORDER BY e.edb_info_id ASC LIMIT ?, ?`
	err = global.DbMap[utils.DbNameIndex].Raw(sql, append(pars, pageIndex, pageSize)...).Find(&list).Error
	return
}

func GetSimpleEdbListCountByCondition(condition string, pars []interface{}) (count int64, err error) {
	sql := `SELECT COUNT(*) FROM edb_info e left join edb_terminal t on e.terminal_code = t.terminal_code WHERE 1=1 ` + condition
	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).Count(&count).Error
	return
}

type SetEdbInfoTerminalReq struct {
	EdbInfoIds []int `description:"指标ID"`
	TerminalCode string `description:"要更换的终端编码"`
	Source int `description:"指标来源类型"`
}


func UpdateEdbInfoTerminal(edbInfoIds []int, terminalCode string, source int) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Exec("UPDATE edb_info SET terminal_code = ? WHERE edb_info_id IN (?) AND source = ?", terminalCode, edbInfoIds, source).Error
	return
}