package cache

import (
	"basic.com/dbapi.git"
	"basic.com/pubsub/cache.git/shardmap"
	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/gopherdiscovery.git"
	"basic.com/valib/logger.git"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gogo/protobuf/proto"
	"github.com/satori/go.uuid"
	"strconv"
)

const (
	PREFIX_CAMERA  = "CAMERA_"
	PREFIX_POLYGON = "POLYGON_"
	PREFIX_TIME    = "TIME_"
	PREFIX_RULE    = "RULE_"
	SERVER_KEY     = "SERVERINFO"
	PREFIX_SDK     = "SDK_"
	PREFIX_DIC     = "DIC_"
	PREFIX_SO      = "SO"
)

var cMap *shardmap.ShardMap

func Init(initChan chan bool, dbIp string, surveyPort int, pubSubPort int) {
	cMap = shardmap.New(uint8(32))
	urlSurvey := "tcp://" + dbIp + ":" + strconv.Itoa(surveyPort)
	urlPubSub := "tcp://" + dbIp + ":" + strconv.Itoa(pubSubPort)
	client, _ := gopherdiscovery.ClientWithSub(urlSurvey, urlPubSub, uuid.NewV4().String())
	recvMsg := client.HeartBeatMsg()
	fmt.Println(<-recvMsg)

	initCacheData(initChan)

	peers, _ := client.Peers()
	for b := range peers {
		fmt.Println("peerMsg:", b)
		updateData(b)
	}
}

func initCacheData(initChan chan bool) {

	initPolygons() //初始化摄像机多边形缓存

	initTimeRules() //初始化时间规则缓存

	initCameraTaskRules() //初始化摄像机任务规则缓存

	initCamera() //初始化摄像机信息

	initServerInfo() //初始化服务器配置信息

	initSdks() //初始化sdk列表信息

	initSoData()

	initDictionary() // 初始化字典

	initChan <- true
}

var newUpdateMsg = &protomsg.DbChangeMessage{}

func updateData(b []byte) {
	if err := proto.Unmarshal(b, newUpdateMsg); err != nil {
		fmt.Println("dbChangeMsg unmarshal err:", err)
		return
	}
	switch newUpdateMsg.Table {
	case protomsg.TableChanged_T_Server:
		initServerInfo()
	case protomsg.TableChanged_T_Camera:
		initCamera()
	case protomsg.TableChanged_T_CameraPolygon: //更新摄像机多变形
		initPolygons()
	case protomsg.TableChanged_T_TimeRule: //更新时间规则
		initTimeRules()
	case protomsg.TableChanged_T_CameraTask: //更新摄像机规则配置参数
		initCameraTaskRules()
	case protomsg.TableChanged_T_CameraTaskArgs: //更新摄像机规则配置参数
		initCameraTaskRules()
	case protomsg.TableChanged_T_Sdk: //更新sdk配置
		initSdks()
	default:
		fmt.Println("unknown operation")

	}
}

func initServerInfo() {
	var api dbapi.SysSetApi
	b, s := api.GetServerInfo()
	if b {
		cMap.Set(SERVER_KEY, s)
	}
}

func initCamera() {
	var api dbapi.CameraApi
	cameras := api.FindAll()
	for _, cam := range cameras {
		cMap.Set(PREFIX_CAMERA+cam.Id, cam)
	}
}

func initPolygons() {
	var api dbapi.CameraApi
	data := api.FindAllPolygons()
	pMap := make(map[string][]protomsg.CameraPolygon, 0)
	for _, item := range data {
		if item.Type != "line" {
			cameraId := item.CameraId
			if _, ok := pMap[cameraId]; ok {
				pMap[cameraId] = append(pMap[cameraId], item)
			} else {
				pMap[cameraId] = []protomsg.CameraPolygon{item}
			}
		}
	}
	for k, v := range pMap {
		cMap.Set(PREFIX_POLYGON+k, v)
	}
}

func initTimeRules() {
	var api dbapi.CameraApi
	flag, rules := api.FindAllTimeRules()
	if flag {
		for _, rule := range rules {
			cMap.Set(PREFIX_TIME+rule.Id, rule)
		}
	}
}

func initDictionary() {
	var api dbapi.DicApi
	flag, dics := api.FindByType("")
	if flag {
		var dicss map[string][]Dic
		b, _ := json.Marshal(dics)
		if err := json.Unmarshal(b, &dicss); err == nil {
			for key, dics1 := range dicss {
				for _, dic := range dics1 {
					logger.Debug("字典缓存初始化", PREFIX_DIC+key+dic.Value, dic)
					cMap.Set(PREFIX_DIC+key+dic.Value, dic)
				}
			}
		}
	}
	logger.Info("取字典缓存：", GetDic(PREFIX_DIC+"nCarColor1"))
}

func initCameraTaskRules() {
	var api dbapi.CameraTaskArgsApi
	all := api.FindAll()

	for _, taskArg := range all {
		cMap.Set(PREFIX_RULE+taskArg.CameraId, taskArg.TaskArgs)
	}
}

func initSdks() {
	var api dbapi.SdkApi
	sdks := api.FindAll("")
	for _, sdk := range sdks {
		cMap.Set(PREFIX_SDK+sdk.Id, sdk)
	}
}

func GetServerInfo() (con protomsg.LocalConfig, err error) {
	config, b := cMap.Get(SERVER_KEY)
	if b {
		return config.(protomsg.LocalConfig), nil
	} else {
		return con, errors.New("conf not found")
	}
}

//通过cameraId获取摄像机信息
func GetCameraById(cameraId string) (c protomsg.Camera, err error) {
	cam, b := cMap.Get(PREFIX_CAMERA + cameraId)
	if b {
		return cam.(protomsg.Camera), nil
	} else {
		return c, errors.New("camera not found")
	}
}

func GetPolygonsByCameraId(cameraId string) []protomsg.CameraPolygon {
	obj, b := cMap.Get(PREFIX_POLYGON + cameraId)
	if b {
		return obj.([]protomsg.CameraPolygon)
	} else {
		return nil
	}
}

//从缓存中获取时间规则
func GetTimeRuleById(id string) (exist bool, rule protomsg.CameraTimerule) {
	obj, b := cMap.Get(PREFIX_TIME + id)
	if b {
		return true, obj.(protomsg.CameraTimerule)
	} else {
		return false, rule
	}
}

//根据摄像机id从缓存中获取摄像机的任务规则设置
func GetCameraTaskRulesByCameraId(cameraId string) []*protomsg.TaskGroupArgs {
	obj, b := cMap.Get(PREFIX_RULE + cameraId)
	if b {
		return obj.([]*protomsg.TaskGroupArgs)
	} else {
		return nil
	}
}

func GetSdkById(sdkId string) (sdk protomsg.Sdk, err error) {
	obj, b := cMap.Get(PREFIX_SDK + sdkId)
	if b {
		return obj.(protomsg.Sdk), nil
	} else {
		return sdk, errors.New("sdk not found")
	}
}

// 获取字典值
func GetDic(key string) (name string) {
	obj, b := cMap.Get(PREFIX_DIC + key)
	if b {
		return obj.(Dic).Name
	} else {
		return ""
	}
}

func initSoData() {
	var api dbapi.SoApi
	soinfos := api.FindAll()
	logger.Debug("=====================注册表信息：")
	for _, soinfo := range soinfos {
		logger.Debug(soinfo)
		cMap.Set(PREFIX_SO+soinfo.SdkId, soinfo)
	}
}

func GetSoInfoById(sdkId string) (sdk protomsg.SoInfo, err error) {
	obj, b := cMap.Get(PREFIX_SO + sdkId)
	if b {
		return obj.(protomsg.SoInfo), nil
	} else {
		return sdk, errors.New("sdk not found")
	}
}

type Dic struct {
	Id          string `json:"id"`
	Value       string `json:"value"`
	Name        string `json:"name"`
	Type        string `json:"type"`
	Description string `json:"description"`
	Sort        int    `json:"sort"`
	Parent_id   string `json:"parent_id"`
}