package cache

import (
	"basic.com/dbapi.git"
	"basic.com/pubsub/cache.git/shardmap"
	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/gopherdiscovery.git"
	"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_"
)

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列表信息

	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 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")
	}
}