package service

import (
	"bytes"
	"encoding/json"
	"io"
	"net/http"
	"time"
	"errors"

	"gat1400Exchange/config"
	"gat1400Exchange/pkg/logger"
	"gat1400Exchange/models"

	"github.com/hashicorp/golang-lru/v2/expirable"
)

var deviceAliveCache *expirable.LRU[string, bool]

func init() {
	deviceAliveCache = expirable.NewLRU[string, bool](100, nil, time.Second*60) //过滤指定时间内的重复人物
}

type DevReportData struct {
	Code        string                 `json:"code"`        // 设备ID
	Type        string                 `json:"type"`        // 设备类型
	Model       string                 `json:"model"`       // 设备型号
	SerialNum   string                 `json:"serialNum"`   // 硬件序列号
	Name        string                 `json:"name"`        // 设备名称
	Org         string                 `json:"org"`         // 所属机构
	Position    string                 `json:"position"`    // 具体位置
	Addr        string                 `json:"addr"`        // 地址
	Longitude   string                 `json:"lon"`         // 经度
	Latitude    string                 `json:"lat"`         // 纬度
	Desc        string                 `json:"desc"`        // 设备描述
	InstallTime string                 `json:"installTime"` // 安装时间
	UpTime      string                 `json:"upTime"`      // 启动时间
	Hardware    map[string]interface{} `json:"hardware"`    // 硬件信息
	IpAddr      string                 `json:"ip"`
}

func reportDeviceInfo() error {
	if config.ForwardConf.ReportServer == "" {
		return errors.New("server addr is empty !")
	}

	var d models.Device
	devices, err := d.FindAll()
	if err != nil {
		return err
	}


	for _, dev := range devices{
		if _, exists := deviceAliveCache.Get(dev.Id); !exists {
			continue
		}

		device := DevReportData{
			Code:      dev.Id,
			Type:      "camera",
			Name:      dev.Name,
			Addr:      dev.Addr+dev.Pos,
			IpAddr:    dev.Ip,
		}

		data, err := json.Marshal(device)
		if err != nil {
			return err
		}

		logger.Info("Report device info. %+v", dev)

		_, err = HttpPost(config.ForwardConf.ReportServer, nil, data)
		if err != nil {
			return err
		}
	}

	return nil
}

func KeepDeviceAlive(id string) {
	deviceAliveCache.Add(id, true)
}

func DeviceInfoReportTask() {
	interval := config.ForwardConf.ReportInterval
	if interval == 0 {
		interval = 10
	}

	logger.Info("start device info report task, server:%s interval:%d.", config.ForwardConf.ReportServer, interval)

	ticker := time.NewTicker(1 * time.Second)
	for {
		select {
		case <-ticker.C:
			err := reportDeviceInfo()
			if err != nil {
				logger.Warn(err.Error())
			}

			ticker.Reset(time.Duration(interval) * time.Second)
		}
	}
}


func HttpPost(url string, header map[string]string, data []byte) ([]byte, error) {
	req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(data))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "applicaiton/json; charset=UTF-8")
	if header != nil {
		for k, v := range header {
			req.Header.Set(k, v)
		}
	}
	cli := &http.Client{}
	resp, err := cli.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	return body, nil
}