package service

import (
	reqUtil "car-service/extend/util"
	"car-service/models"
	"car-service/vo"
	"encoding/json"
	"fmt"
	"github.com/astaxie/beego"
)
type CarService struct {
	hikUtil *reqUtil.HikHttpUtil
}

func NewCarService() *CarService {
	return &CarService{
		hikUtil: &reqUtil.HikHttpUtil{
			AppKey: hikAppKey,
			AppSecret: hikAppSecret,
			ReqHost: beego.AppConfig.String("hikUrl"),
		},
	}
}

func (sv *CarService) Statistic() (*models.CarStatistic, bool) {
	m := models.CarStatistic{
		TotalPermPlace: 0,
		Left:           0,
	}
	parkList := sv.getHikParkList() //先查有几个停车场
	flag := false
	if parkList != nil {
		flag = true
		for _,p := range parkList {
			remainList := sv.getRemainSpaceNum(p.ParkIndexCode)
			if remainList != nil {
				for _,r := range remainList {
					m.Left += r.LeftPlace
					m.TotalPermPlace += r.LeftPermPlace
				}
			}
		}
	}

	return &m, flag
}

type ParkInfo struct {
	ParkIndexCode  			string  		`json:"parkIndexCode"`
	ParentParkIndexCode 	string 			`json:"parentParkIndexCode"`
	ParkName 				string 			`json:"parkName"`
	CreateTime 				string 			`json:"createTime"`
	UpdateTime 				string 			`json:"updateTime"`
}

var (
	hikAppKey = "27107808"
	hikAppSecret = "BEQiCoBTYcJX2d4KzbVK"
)


//获取海康停车库列表
func (sv *CarService) getHikParkList() []ParkInfo {
	url := "/artemis/api/resource/v1/park/parkList"
	reqBody := map[string]interface{}{}

	result := sv.hikUtil.Post(url, reqBody)
	if result == nil {
		fmt.Println("sv.hikUtil.Post get nil")
		return nil
	}

	if result.Code == reqUtil.HikResult_Success {
		dbytes, err := json.Marshal(result.Data)
		if err !=nil {
			fmt.Println("marshal result.data err:", err)
			return nil
		}
		var pList []ParkInfo
		err = json.Unmarshal(dbytes, &pList)
		if err != nil {
			fmt.Println("unmarshal []ParkInfo err:", err)
			return nil
		}
		return pList
	} else {
		fmt.Println("result ret fail, result:", result)
		return nil
	}
}

type RemainSpaceResult struct {
	ParkSysCode 			string 			`json:"parkSyscode"`        //停车库唯一标识码
	ParkName 				string 			`json:"parkName"`           //停车库名称
	ParentParkSyscode 		string 			`json:"parentParkSyscode"`  //父停车库唯一标识
	TotalPlace 				int 			`json:"totalPlace"`        //停车库车位总数
	TotalPermPlace 			int 			`json:"totalPermPlace"`    //停车库固定车位总数
	TotalReservePlace 		int 			`json:"totalReservePlace"` //停车位预约车位总数
	LeftPlace 				int 			`json:"leftPlace"`     //停车库车位剩余数
	LeftPermPlace 			int 			`json:"leftPermPlace"` //停车库固定车位剩余数
	LeftReservePlace 		int 			`json:"leftReservePlace"` //停车库预约车位剩余数
}

func (sv *CarService) getRemainSpaceNum(parkIndexCode string) []RemainSpaceResult {
	url := "/artemis/api/pms/v1/park/remainSpaceNum"
	reqBody := map[string]interface{}{
		"parkSyscode": parkIndexCode,
	}

	result := sv.hikUtil.Post(url, reqBody)
	if result == nil {
		fmt.Println("sv.hikUtil.Post get nil")
		return nil
	}

	if result.Code == reqUtil.HikResult_Success {
		dbytes, err := json.Marshal(result.Data)
		if err !=nil {
			fmt.Println("marshal result.data err:", err)
			return nil
		}
		var remainList []RemainSpaceResult
		err = json.Unmarshal(dbytes, &remainList)
		if err != nil {
			fmt.Println("unmarshal []RemainSpaceResult err:", err)
			return nil
		}
		return remainList
	}
	return nil
}

type SpaceNo struct {
	SpaceSyscode  			string 		`json:"spaceSyscode"`
	SpaceNo 				string 		`json:"spaceNo"`
	ParkSyscode 			string 		`json:"parkSyscode"`
	ParkName 				string 		`json:"parkName"`
	FloorSyscode 			string 		`json:"floorSyscode"`
	FloorName 				string 		`json:"floorName"`
	Longitude 				string 		`json:"longitude"`
	Latitude 				string 		`json:"latitude"`
	CameraSyscode 			string 		`json:"cameraSyscode"`
	State 					int 		`json:"state"`
	ParkingTime 			string 		`json:"parkingTime"`
	SpacePicUri 			string 		`json:"spacePicUri"`
	PlateNoPicUri 			string 		`json:"plateNoPicUri"`
	AswSyscode 				string 		`json:"aswSyscode"`
	PlateNos				string 		`json:"plateNos"`
	AlarmPlateNos 			string 		`json:"alarmPlateNos"`
	SpaceType 				string 		`json:"spaceType"`
}

func (sv *CarService) FindSpaceNo() models.PosResult {
	resultList := make(models.PosResult,0)

	//先查车库唯一标识
	//parkList := sv.getHikParkList() //先查有几个停车场
	//if parkList != nil {
		url := "/artemis/api/pms/v1/parkingSpace/spaceNo"
		//for _,p := range parkList {
			reqBody := map[string]interface{} {
				//"parkSyscode": p.ParkIndexCode,//停车库唯一标识
				//"state": 1, //车位状态，0：空闲，1：停车
				"pageNo": 1,
				"pageSize": 1000,
			}
			pageResult := sv.getHikPageResult(url, reqBody)
			fmt.Println("findSpaceNo pageResult:", pageResult)
			if pageResult != nil {
				rb, err := json.Marshal(pageResult.List)
				if err != nil {
					fmt.Println("marshal pageResult.List err:",err)
					return nil
				}
				var spaceList []SpaceNo
				err = json.Unmarshal(rb, &spaceList)
				if err != nil {
					fmt.Println("unmarshal spaceNos err:",err)
					return nil
				}
				for _,s := range spaceList {
					pi := models.PosInfo {
						SpaceNo: s.SpaceNo,
						PosNo: "",
						State: s.State,
						PlateNo: s.PlateNos,
					}
					if v,ok := models.SpaceNo2Pos[s.SpaceNo];ok {
						pi.PosNo = v
					}
					resultList = append(resultList, pi)
				}
			}
		//}
	//}

	return resultList
}

func (sv *CarService) BindCarSpace() bool {
	url := "/artemis/api/pms/v1/parking_space/car_bind/add"
	reqBody := map[string]interface{} {
		"spaceNos": "", //绑定的车位集
		"floorSyscode": "",//楼层唯一标识码
		"plateNos": "", //绑定的车牌集合，多个用逗号隔开
	}
	fmt.Println(url, reqBody)
	return true
}

type HikPerson struct {
	PersonId        				string           	`json:"personId"`
	PersonName      				string           	`json:"personName"`
	Gender          				int              	`json:"gender"`
	PhoneNo         				string           	`json:"phoneNo"`
	JobNo           				string           	`json:"jobNo"`
	OrgIndexCode    				string           	`json:"orgIndexCode"`
	CertificateType 				string           	`json:"certificateCode"`
	CertificateNo   				string           	`json:"certificateNo"`
	CreateTime      				string           	`json:"createTime"`
	UpdateTime      				string           	`json:"updateTime"`
	OrgPath         				string           	`json:"orgPath"`
	OrgPathName     				string           	`json:"orgPathName"`
	PersonPhone     				[]HikPersonPhoto 	`json:"personPhoto"`
}

type HikPersonPhoto struct {
	PersonPhotoIndexCode 			string 				`json:"personPhotoIndexCode"`
	PicUri 							string 				`json:"picUri"`
	ServerIndexCode 				string 				`json:"serverIndexCode"`
	PersonId 						string 				`json:"personId"`
}

func (sv *CarService) GetHikPersonList() []HikPerson {
	url := "/artemis/api/resource/v2/person/personList"
	pageSize := 1000
	reqBody := map[string]interface{} {
		"pageNo": 1,
		"pageSize": pageSize,
	}
	pageResult := sv.getHikPageResult(url, reqBody)
	if pageResult == nil {
		return nil
	}
	b,err := json.Marshal(pageResult.List)
	if err != nil {
		fmt.Println("marshal pageResult.List err:", err)
		return nil
	}
	var list []HikPerson
	if err = json.Unmarshal(b, &list);err != nil {
		fmt.Println("unmarshal err:", err)
		return nil
	}
	if pageResult.Total > pageSize {
		times := pageResult.Total / pageSize
		if pageResult.Total % pageSize > 0 {
			times++
		}
		for i:=1;i<times;i++ {
			tpr := sv.getHikPageResult(url, map[string]interface{}{
				"pageNo": i+1,
				"pageSize": pageSize,
			})
			if tpr != nil {
				tb,e := json.Marshal(tpr.List)
				if e != nil {
					fmt.Println("marshal tpr.List err:", e)
					continue
				}
				var tprList []HikPerson
				if e = json.Unmarshal(tb, &tprList);e ==nil {
					list = append(list, tprList...)
				} else {
					fmt.Println("unmarshal tprList err:", e)
				}
			} else {
				fmt.Println("total:", pageResult.Total, "tpr is nil")
			}
		}
	}

	return list
}

func (sv *CarService) getHikPageResult(url string, reqBody map[string]interface{}) *vo.HikPageResult {
	fmt.Println(url, reqBody)
	result := sv.hikUtil.Post(url, reqBody)
	if result.Code == reqUtil.HikResult_Success {
		b, err := json.Marshal(result.Data)
		if err == nil {
			var pageResult vo.HikPageResult
			if err = json.Unmarshal(b, &pageResult); err == nil {
				return &pageResult
			} else {
				fmt.Println("unmarshal pageResult err:", err)
			}
		} else {
			fmt.Println("marshal result.Data err:", err)
		}
	} else {
		fmt.Println("result:", result)
	}
	return nil
}

type HikVehicle struct {
	VehicleId 				string 			`json:"vehicleId"`
	PlateNo 				string 			`json:"plateNo"`
	PersonId 				string 			`json:"personId"`
	RegionIndexCode 		string 			`json:"regionIndexCode"`
	PlateType 				int 			`json:"plateType"`
	PlateColor 				int 			`json:"plateColor"`
	VehicleType 			int 			`json:"vehicleType"`
	VehicleColor 			int 			`json:"vehicleColor"`
	Description 			string 			`json:"description"`
	CreateTime 				string 			`json:"createTime"`
	UpdateTime 				string 			`json:"updateTime"`
	RegionName 				string 			`json:"regionName"`
	RegionPath 				string 			`json:"regionPath"`
	RegionPathName 			string 			`json:"regionPathName"`
	IsBandPerson 			int 			`json:"isBandPerson"`
	PersonName 				string 			`json:"personName"`
	OrgPath 				string 			`json:"orgPath"`
	OrgPathName 			string 			`json:"orgPathName"`
}

//获取指定人员的车辆车牌信息
func (sv *CarService) GetVehicleListByPerson(personId string) []HikVehicle {
	url := "/artemis/api/resource/v2/vehicle/advance/vehicleList"
	reqBody := map[string]interface{} {
		"pageNo": 1,
		"pageSize": 100,
		"personIds": personId,
	}
	pageResult := sv.getHikPageResult(url, reqBody)
	if pageResult ==nil {
		return nil
	}

	b, err := json.Marshal(pageResult.List)
	if err == nil {
		var list []HikVehicle
		if err = json.Unmarshal(b, &list);err == nil {
			return list
		}
	}

	return nil
}