package models

import (
	"fmt"
	"github.com/beego/beego/v2/client/orm"
	"hongze/hongze_edb_lib/utils"
	"time"
)

// EdbDataCalculateZjpj 直接拼接数据结构体
type EdbDataCalculateZjpj struct {
	EdbDataId     int `orm:"column(edb_data_id);pk"`
	EdbInfoId     int
	EdbCode       string
	DataTime      string
	Value         float64
	Status        int
	CreateTime    time.Time
	ModifyTime    time.Time
	DataTimestamp int64
}

// AddCalculateZjpj 新增直接拼接数据
func AddCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
	o := orm.NewOrm()
	to, err := o.Begin()
	if err != nil {
		return
	}
	defer func() {
		if err != nil {
			fmt.Println("AddCalculateZjpj,Err:" + err.Error())
			_ = to.Rollback()
		} else {
			_ = to.Commit()
		}
	}()
	var edbInfo *EdbInfo
	if req.EdbInfoId <= 0 {
		edbInfo = &EdbInfo{
			SourceName:       "直接拼接",
			Source:           utils.DATA_SOURCE_CALCULATE_ZJPJ,
			EdbCode:          edbCode,
			EdbName:          req.EdbName,
			EdbNameSource:    req.EdbName,
			Frequency:        req.Frequency,
			Unit:             req.Unit,
			StartDate:        firstEdbInfo.StartDate,
			EndDate:          firstEdbInfo.EndDate,
			ClassifyId:       req.ClassifyId,
			SysUserId:        sysUserId,
			SysUserRealName:  sysUserRealName,
			UniqueCode:       uniqueCode,
			CreateTime:       time.Now(),
			ModifyTime:       time.Now(),
			CalculateFormula: req.Formula,
			EdbType:          2,
		}
		newEdbInfoId, err := to.Insert(edbInfo)
		if err != nil {
			return edbInfoId, err
		}
		edbInfoId = int(newEdbInfoId)
	} else {
		edbInfoId = req.EdbInfoId
		//查询
		tmpEdbInfo, tmpErr := GetEdbInfoById(edbInfoId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		tmpEdbInfo.EdbName = req.EdbName
		tmpEdbInfo.ClassifyId = req.ClassifyId
		tmpEdbInfo.Frequency = req.Frequency
		tmpEdbInfo.Unit = req.Unit
		tmpEdbInfo.CalculateFormula = req.Formula

		edbInfo = tmpEdbInfo

		//删除指标数据
		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_ZJPJ)
		fmt.Println("dataTableName:" + dataTableName)
		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
		if err != nil {
			return 0, err
		}

		//删除指标关系
		sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id=? `
		_, err = to.Raw(sql, edbInfoId).Exec()
	}

	//关联关系

	//第一个指标
	{
		calculateMappingItem := new(EdbInfoCalculateMapping)
		calculateMappingItem.CreateTime = time.Now()
		calculateMappingItem.ModifyTime = time.Now()
		calculateMappingItem.Sort = 1
		calculateMappingItem.EdbCode = edbCode
		calculateMappingItem.EdbInfoId = edbInfoId
		calculateMappingItem.FromEdbInfoId = firstEdbInfo.EdbInfoId
		calculateMappingItem.FromEdbCode = firstEdbInfo.EdbCode
		calculateMappingItem.FromEdbName = firstEdbInfo.EdbName
		calculateMappingItem.FromSource = firstEdbInfo.Source
		calculateMappingItem.FromSourceName = firstEdbInfo.SourceName
		calculateMappingItem.FromTag = "A"
		calculateMappingItem.Source = edbInfo.Source
		calculateMappingItem.SourceName = edbInfo.SourceName
		_, err = to.Insert(calculateMappingItem)
		if err != nil {
			return
		}
	}

	//第二个指标
	{
		calculateMappingItem := new(EdbInfoCalculateMapping)
		calculateMappingItem.CreateTime = time.Now()
		calculateMappingItem.ModifyTime = time.Now()
		calculateMappingItem.Sort = 1
		calculateMappingItem.EdbCode = edbCode
		calculateMappingItem.EdbInfoId = edbInfoId
		calculateMappingItem.FromEdbInfoId = secondEdbInfo.EdbInfoId
		calculateMappingItem.FromEdbCode = secondEdbInfo.EdbCode
		calculateMappingItem.FromEdbName = secondEdbInfo.EdbName
		calculateMappingItem.FromSource = secondEdbInfo.Source
		calculateMappingItem.FromSourceName = secondEdbInfo.SourceName
		calculateMappingItem.FromTag = "B"
		calculateMappingItem.Source = edbInfo.Source
		calculateMappingItem.SourceName = edbInfo.SourceName
		_, err = to.Insert(calculateMappingItem)
		if err != nil {
			return
		}
	}

	addDataList := make([]*EdbDataCalculateZjpj, 0)

	//拼接数据

	//第一个指标
	{
		var condition string
		var pars []interface{}

		condition += " AND data_time < ? AND edb_info_id=? "
		pars = append(pars, req.Formula, firstEdbInfo.EdbInfoId)

		//第一个指标的数据列表
		firstDataList, tmpErr := GetEdbDataListAll(condition, pars, firstEdbInfo.Source, 0)
		if tmpErr != nil {
			return edbInfoId, tmpErr
		}

		for _, v := range firstDataList {
			//时间戳
			currentDate, _ := time.Parse(utils.FormatDate, v.DataTime)
			timestamp := currentDate.UnixNano() / 1e6

			edbDataZjpj := &EdbDataCalculateZjpj{
				EdbInfoId:     edbInfoId,
				EdbCode:       edbInfo.EdbCode,
				DataTime:      v.DataTime,
				Value:         v.Value,
				Status:        1,
				CreateTime:    time.Now(),
				ModifyTime:    time.Now(),
				DataTimestamp: timestamp,
			}
			addDataList = append(addDataList, edbDataZjpj)
			if len(addDataList) >= 200 {
				_, tmpErr := to.InsertMulti(len(addDataList), addDataList)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				//重新初始化需要加入的数据切片
				addDataList = make([]*EdbDataCalculateZjpj, 0)
			}
		}
	}

	//第二个指标
	{
		var condition string
		var pars []interface{}

		condition += " AND data_time >= ? AND edb_info_id = ? "
		pars = append(pars, req.Formula, secondEdbInfo.EdbInfoId)

		//第二个指标的数据列表
		secondDataList, tmpErr := GetEdbDataListAll(condition, pars, secondEdbInfo.Source, 0)
		if tmpErr != nil {
			return edbInfoId, tmpErr
		}

		for _, v := range secondDataList {
			//时间戳
			currentDate, _ := time.Parse(utils.FormatDate, v.DataTime)
			timestamp := currentDate.UnixNano() / 1e6

			edbDataZjpj := &EdbDataCalculateZjpj{
				EdbInfoId:     edbInfoId,
				EdbCode:       edbInfo.EdbCode,
				DataTime:      v.DataTime,
				Value:         v.Value,
				Status:        1,
				CreateTime:    time.Now(),
				ModifyTime:    time.Now(),
				DataTimestamp: timestamp,
			}
			addDataList = append(addDataList, edbDataZjpj)
			if len(addDataList) >= 200 {
				_, tmpErr := to.InsertMulti(len(addDataList), addDataList)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				//重新初始化需要加入的数据切片
				addDataList = make([]*EdbDataCalculateZjpj, 0)
			}
		}
	}

	//将剩余的数据入库
	if len(addDataList) > 0 {
		_, tmpErr := to.InsertMulti(len(addDataList), addDataList)
		if tmpErr != nil {
			err = tmpErr
			return
		}
	}
	return
}