package devices

import (
	"bytes"
	"encoding/json"
	"errors"
	"gorm.io/gorm"
	"net/http"
	"server/dao/devices"
	promodel "server/model/common/devices"
	"server/model/common/request"
	model "server/model/devices"
	"server/service/tcp"
	"server/utils/logger"
	"time"
)

type ScreensService struct{}

func (screensService *ScreensService) GetScreensInfoList(info request.PageInfo) (list interface{}, total int64, err error) {
	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)
	keyword := info.Keyword
	shunt := info.Shunt

	screensList, total, err := devices.QueryScreensInfoList(limit, offset, keyword, shunt)

	for i, screens := range screensList {
		screensList[i].Status = tcp.Devices[screens.Sn].Info.Status
		screensList[i].LastOfflineTime = tcp.Devices[screens.Sn].Info.LastOfflineTime
		screensList[i].LastOnlineTime = tcp.Devices[screens.Sn].Info.LastOnlineTime
	}

	return screensList, total, err
}

func (screensService *ScreensService) QueryScreensParms() (list interface{}, err error) {
	resolution := devices.Resolution{}
	getResolution, err := resolution.GetResolution()

	screensSize := devices.ScreensSize{}
	getScreensSize, err := screensSize.GetScreensSize()

	way := devices.GateWay{}
	gatewayList, err := way.PublicGateway()

	params := model.RspParams{Resolution: getResolution, ScreensSize: getScreensSize, PubGateway: gatewayList}

	return params, err
}

func (screensService *ScreensService) DelScreens(sn string) error {
	s := devices.Screens{}
	err := s.DelScreens(sn)
	delete(tcp.Devices, sn)
	return err
}

func (screensService *ScreensService) AddScreens(screens devices.Screens) error {
	err := screens.IsExistedByCode()
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		logger.Logger.Errorf("Create IsExistedByCode \n")
		return errors.New("设备编码已存在！")
	}
	err = screens.AddScreens()

	//将该屏信息添加到内存中
	tcp.Devices[screens.Sn] = &tcp.Device{Info: screens}
	return err
}

func (screensService *ScreensService) UpdateScreens(screens devices.Screens, oldSn string) error {
	for s, _ := range tcp.Devices {
		if s == screens.Sn && oldSn != screens.Sn { //判断修改的新的sn是否已存在，存在这不让修改，
			return errors.New("设备Sn重复")
		}
	}

	//如果改了其它参数，没改sn，则只更新内存中的设备基础信息，且数据库中的原有status、LastOnlineTime、LastOfflineTime不做修改
	if oldSn == screens.Sn {
		tcp.Devices[screens.Sn].Info = screens
		err := screens.UpdateScreens()
		if err != nil {
			return errors.New("修改失败")
		}
		return nil
	}
	//如果改了sn 则要修改内存和数据库中的status、LastOnlineTime、LastOfflineTime信息
	screens.Status = 0
	var empty *time.Time
	screens.LastOnlineTime = empty
	screens.LastOfflineTime = empty
	err := screens.UpdateScreens()
	if err != nil {
		return errors.New("修改失败")
	}
	//从内存中删除原有的资源，并添加新的
	delete(tcp.Devices, oldSn)
	screens.Status = 0
	screens.LastOnlineTime = empty
	screens.LastOfflineTime = empty
	tcp.Devices[screens.Sn] = &tcp.Device{Info: screens}
	return nil
}

/**
以下是关于设备操作的一些业务方法
*/

// 开关屏
func (screensService *ScreensService) SwitchScreens(swatch promodel.SwitchScreens) error {
	//判断组网方式 0代表网关 1代表4G模块
	err := tcp.SwitchScreen(swatch.Sn, swatch.Flag)
	if err != nil {
		logger.Logger.Errorf("SwitchScreens faild,error: %v \n", err)
		return errors.New("开关屏幕失败！")
	}
	return nil
}

// 发送内码文字
func (screensService *ScreensService) SendInternalCode(sn string, content []promodel.InternalCodeContent) error {
	err := tcp.SendInternalCode(sn, content)
	if err != nil {
		logger.Logger.Errorf("SendInternalCode faild,error: %v \n", err)
		return errors.New("发送内码文字失败！")
	}
	return nil
}

// 远程喊话
func (screensService *ScreensService) VoiceBroad(sn string, content string) error {
	err := tcp.VoiceBroad(sn, content)
	if err != nil {
		logger.Logger.Errorf("SendInternalCode faild,error: %v \n", err)
		return errors.New("远程喊话失败！")
	}
	return nil
}

// 设置屏幕亮度和声音开关时间
func (screensService *ScreensService) SetBrightAudioLed(sb model.ReqBrightness) error {
	//先将白天、晚上亮度 声音开关时间 更新到数据库
	screens := devices.Screens{}
	err := screens.UpdateBrightAudioLedBySn(sb.Sn, sb.DayBright, sb.NightBright, sb.AudioOn, sb.AudioOff, sb.LedOn, sb.LedOff)
	if err != nil {
		logger.Logger.Errorf("SetBright faild,error: %v \n", err)
		return errors.New("亮度更新数据库失败！")
	}

	//修改屏幕亮度   判断当前时间是白天还是晚上(立马去更改当前所处时间的亮度)
	currentTime := time.Now()
	hour := currentTime.Hour()
	minute := currentTime.Minute()

	// 判断当前时间是否在 8:00 到 18:00 之间
	if (hour > 8 || (hour == 8 && minute >= 0)) && (hour < 18) {
		//白天
		err = tcp.SetBrightness(sb.Sn, sb.DayBright)
		if err != nil {
			logger.Logger.Errorf("SetBright[白天] faild,error: %v \n", err)
			return errors.New("设置白天亮度失败！")
		}
	} else {
		//晚上
		err = tcp.SetBrightness(sb.Sn, sb.NightBright)
		if err != nil {
			logger.Logger.Errorf("SetBright[晚上] faild,error: %v \n", err)
			return errors.New("设置晚上亮度失败！")
		}
	}

	//修改时控开关时间
	err = SetSwitchClock([]string{sb.SwitchSn}, sb.AudioOn, sb.AudioOff)
	if err != nil {
		logger.Logger.Errorf("SetSwitchClock faild,error: %v \n", err)
		return err
	}
	return nil
}

func SetSwitchClock(switchSn []string, audioOn, audioOff string) error {
	//目标接口的 URL
	url := "https://cloud.long-chi.com/lczh_wxapp_api/dev/batchUpdateDeviceTime"

	token := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVVUlEIjoiYjFkZDU2MGItM2RmNC00MTg0LWE2NzktODYyM2M1Y2I3ZDVkIiwiSUQiOjI0MCwiVXNlcm5hbWUiOiJzbWFydEludGVyc2VjdGlvbiIsIk5pY2tOYW1lIjoi5pm65oWn6Lev5Y-jIiwiQXV0aG9yaXR5SWQiOjk5OTk5LCJPcGVuaWQiOiIiLCJCdWZmZXJUaW1lIjo4NjQwMCwiaXNzIjoicW1QbHVzIiwiZXhwIjo0MTAyMzI5NjAwLCJhdWQiOiJHVkEiLCJuYmYiOjE3MzE5OTc5MDl9.DTWzlXPNbQ9bT7pX_X_tvJ06oW9bngPLKXsFNb54uV4"

	params := model.BatchUpdateDeviceTime{
		DeviceSn: switchSn,
		TimeSetData: model.DeviceRelay{
			TimeCondition1OnTime:  audioOn,  //声音开时间
			TimeCondition1OffTime: audioOff, //声音关时间
		},
	}

	buf, err := json.Marshal(&params)
	if err != nil {
		logger.Logger.Errorf("Fail to marshal [SetSwitchClock], error: %v \n", err)
		return err
	}
	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(buf))
	if err != nil {
		logger.Logger.Errorf("Fail to create request [SetSwitchClock], error: %v \n", err)
		return err
	}

	// 在请求头中添加x-token字段，值为<Token>
	req.Header.Add("x-token", token)
	req.Header.Add("Content-Type", "application/json")

	// 创建一个 HTTP 客户端
	client := &http.Client{}

	// 发送请求
	resp, err := client.Do(req)
	if err != nil {
		logger.Logger.Errorf("Fail to Do request [SetSwitchClock], error: %v \n", err)
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return errors.New("设置声音时控 fail")
	}
	return nil
}