package service

import (
	"encoding/json"
	"errors"
	"fmt"
	"vamicro/extend/util"
	"vamicro/scene-service/models"

	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/logger.git"
)

type TimeService struct {
	Bk bhomeclient.Broker
}

func (sv *TimeService) Save(model models.CameraTimerule) error {
	// 判断时间规则是否重复
	// 如果是修改name，不用做去重校验
	timeRule := models.CameraTimerule{}
	if timeRule.Exists(model.Id) && timeRule.Name == model.Name {
		var data []*models.DayCtl
		if err := json.Unmarshal([]byte(model.TimeRule), &data); err != nil {
			msg := fmt.Sprintf("比较时间规则 Unmarshal err=%v", err)
			logger.Error(msg)
			return errors.New(msg)
		}
		// 逻辑有误, 暂时屏蔽
		//isRepeat, err := IsTimeRuleRepeat(data)
		//logger.Debugf("IsTimeRuleRepeat result isRepeat=%v, err=%v", isRepeat, err)
		//if err != nil {
		//	msg := fmt.Sprintf("比较时间规则 IsTimeRuleRepeat err=%v", err)
		//	logger.Error(msg)
		//	return errors.New(msg)
		//}
		//if isRepeat {
		//	logger.Debugf("timerule save id=%v, 时间规则重复", model.Id)
		//	return errors.New("时间规则重复")
		//}
	}

	if model.Id != "" { //更新
		if model.Update() {
			datas, _ := json.Marshal(model)
			pMsg := protomsg.DbChangeMessage{
				Id:     model.Id,
				Table:  protomsg.TableChanged_T_TimeRule,
				Action: protomsg.DbAction_Update,
				Info:   string(datas),
			}
			pb, _ := json.Marshal(pMsg)
			logger.Debugf("timerule Save Update model=%v", model)
			sv.Bk.Publish(ProcName, pb)
			return nil
		}
	} else { //新增
		model.Id = util.PseudoUuid()
		if model.Insert() {
			datas, _ := json.Marshal(model)
			pMsg := protomsg.DbChangeMessage{
				Id:     model.Id,
				Table:  protomsg.TableChanged_T_TimeRule,
				Action: protomsg.DbAction_Insert,
				Info:   string(datas),
			}
			pb, _ := json.Marshal(pMsg)
			logger.Debugf("timerule Save Insert model=%v", model)
			sv.Bk.Publish(ProcName, pb)
			return nil
		}
	}
	return errors.New("unknow error!!!")
}

func (sv *TimeService) DeleteById(timeRuleId string, force bool) (bool, error) {
	if !force { //非强制删除时，需要验证是否在使用中
		var crg models.CameraRuleGroup
		if timeRules, _ := crg.FindByTimeRuleId(timeRuleId); len(timeRules) > 0 {
			return false, errors.New("场景使用中，不能删除")
		}
	}

	var model models.CameraTimerule
	rows, err := model.DeleteById(timeRuleId)
	if err == nil && rows > 0 {
		pMsg := protomsg.DbChangeMessage{
			Id:     timeRuleId,
			Table:  protomsg.TableChanged_T_TimeRule,
			Action: protomsg.DbAction_Delete,
			Info:   fmt.Sprintf("{\"id\":\"%v\"}", timeRuleId),
		}
		pb, _ := json.Marshal(pMsg)
		sv.Bk.Publish(ProcName, pb)
		return true, nil
	}

	return false, errors.New("删除记录失败")
}

// 判断时间规则是否重复
func IsTimeRuleRepeat(srcData []*models.DayCtl) (bool, error) {
	if len(srcData) != 7 {
		logger.Errorf("IsTimeRuleRepeat 时间规则格式错误")
		return false, errors.New("时间规则格式错误")
	}
	timeRule := models.CameraTimerule{}
	records, err := timeRule.FindAll()
	if err != nil {
		logger.Errorf("IsTimeRuleRepeat FindAll err=%v", err)
		return false, err
	}
	logger.Debugf("IsTimeRuleRepeat len(srcData)=%v, len(records)=%v", len(srcData), len(records))
	for _, r := range records {
		var listData []*models.DayCtl
		if err := json.Unmarshal([]byte(r.TimeRule), &listData); err != nil {
			logger.Errorf("IsTimeRuleRepeat Unmarshal err=%v", err)
			return false, err
		}
		if len(listData) != 7 {
			logger.Errorf("IsTimeRuleRepeat db里的数据时间规则格式错误")
			return false, errors.New("db里的数据时间规则格式错误")
		}
		// 和db里的一条记录比较，如果相等就返回，否则继续比较下一条记录
		var findEqual bool
		for i := 0; i < 7; i++ {
			b, err := EqualDays(listData[i].TimeRange, srcData[i].TimeRange)
			if err != nil {
				logger.Errorf("IsTimeRuleRepeat EqualDays err=%v", err)
				return false, err
			}
			if b {
				findEqual = true
				continue
			}
			// 找到不相等
			findEqual = false
			break
		}

		if findEqual {
			logger.Debugf("IsTimeRuleRepeat timerule is repeat id=%v, name=%v, timeRule=%v", r.Id, r.Name, r.TimeRule)
			return true, nil
		}
	}
	return false, nil
}

// 判断是否 d1 == d1: true, 否则返回false
func EqualDays(d1, d2 []models.TimeRange) (bool, error) {
	if len(d1) != len(d2) {
		logger.Errorf("IsTimeRuleRepeat EqualDays len(d1)=%v, len(d2)=%v, d1=%v, d2=%v", len(d1), len(d2), d1, d2)
		return false, nil
	}

	if len(d1) == 0 || len(d2) == 0 {
		return true, nil
	}

	for i := 0; i < 1; i++ {
		if d1[i].Start != d2[i].Start || d1[i].End != d2[i].End {
			return false, nil
		}
	}
	return true, nil
}