package service

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

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

func (sv *CarService) Statistic() (*models.CarStatistic, bool) {
	m := models.CarStatistic{
		TotalPlace: 0,
		Left:       0,
	}

	remainList := sv.getRemainSpaceNum("")
	if remainList != nil {
		for _,r:=range remainList {
			m.TotalPlace += r.TotalPlace
			m.Left += r.LeftPlace
		}
		return &m, true
	} else {
		return &m, false
	}
}

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


//获取海康停车库列表
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"`
	PlateNo					string 		`json:"plateNo"`
	AlarmPlateNos 			string 		`json:"alarmPlateNos"`
	SpaceType 				string 		`json:"spaceType"`
}

func (sv *CarService) FindHikSpaceInfo(userId string) []SpaceNo {
	url := "/artemis/api/pms/v1/parkingSpace/spaceNo"

	reqBody := map[string]interface{} {
		"pageNo": 1,
		"pageSize": 1000,
	}
	pageResult := sv.getHikPageResult(url, reqBody)
	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
		} else {
			curLoginManagerPhone := ""
			personMap := sv.GetHikPersonMap()
			if userId != "" {
				if mm,ok := personMap[userId];ok {
					curLoginManagerPhone = mm.PhoneNo
				}
			}
			isSuper := false
			if curLoginManagerPhone != "" {
				superPhoneArr := strings.Split(beego.AppConfig.String("superManagerPhones"), ",")
				if superPhoneArr != nil {
					for _,sp := range superPhoneArr {
						if sp == curLoginManagerPhone { //是超级管理员
							isSuper = true
							break
						}
					}
				}
			}

			vipPlateNoArr := getVipPlateNoArr()

			var resultArr []SpaceNo
			for _,si := range spaceList {
				if si.State == 1 { //有车
					if isSuper {
						resultArr = append(resultArr, si)
					} else {
						if isSpaceShow(vipPlateNoArr, si.PlateNo) {
							resultArr = append(resultArr, si)
						}
					}
				}
			}
			return resultArr
		}
	}
	return nil
}


type SpaceUser struct {
	SpaceNo 	string 			`json:"spaceNo"`
	PlateNo 	string 			`json:"plateNo"`
	Username 	string 			`json:"username"`
	PhoneNum 	string 			`json:"phoneNum"`
	CarType 	string 			`json:"carType"`
}

type SpaceUserArr []SpaceUser
func (arr SpaceUserArr) Len()int {
	return len(arr)
}
func (arr SpaceUserArr) Swap(i,j int) {
	arr[i],arr[j] = arr[j],arr[i]
}
func (arr SpaceUserArr) Less(i,j int) bool {
	sn1,_ := strconv.Atoi(arr[i].SpaceNo)
	sn2,_ := strconv.Atoi(arr[j].SpaceNo)
	return sn1 < sn2
}

func (sv *CarService) FindHikSpaceUser(userId string) SpaceUserArr {
	resultList := make(SpaceUserArr, 0)
	url := "/artemis/api/pms/v1/parkingSpace/spaceNo"
	reqBody := map[string]interface{} {
		"pageNo": 1,
		"pageSize": 1000,
	}
	pageResult := sv.getHikPageResult(url, reqBody)
	if pageResult != nil {
		rb, err := json.Marshal(pageResult.List)
		if err != nil {
			fmt.Println("marshal pageResult.List err:", err)
		} else {
			var spaceList []SpaceNo
			err = json.Unmarshal(rb, &spaceList)
			if err != nil {
				fmt.Println("unmarshal spaceNos err:", err)
			} else {
				if len(spaceList) > 0 { //当前有停留车
					personMap := sv.GetHikPersonMap()
					vehicleMap := sv.GetHikVehicleMap()
					curLoginManagerPhone := ""
					if userId != "" {
						if mm,ok := personMap[userId];ok {
							curLoginManagerPhone = mm.PhoneNo
						}
					}
					isSuper := false
					if curLoginManagerPhone != "" {
						superPhoneArr := strings.Split(beego.AppConfig.String("superManagerPhones"), ",")
						if superPhoneArr != nil {
							for _,sp := range superPhoneArr {
								if sp == curLoginManagerPhone { //是超级管理员
									isSuper = true
									break
								}
							}
						}
					}

					vipPlateNoArr := getVipPlateNoArr()

					for _,sp := range spaceList {
						if sp.State == 1 {
							su := SpaceUser{
								SpaceNo: sp.SpaceNo,
								PlateNo: sp.PlateNo,
							}
							if sp.PlateNo != "" {
								r := []rune(sp.PlateNo)
								ncStr := string(r[1:]) //把第一位汉字剔除掉
								newK := strings.ReplaceAll(ncStr, "D", "*")
								newK = strings.ReplaceAll(newK, "0", "*")
								personId := ""
								if v,exist := vehicleMap[newK]; exist {
									personId = v.PersonId
								}

								if personId != "" {
									su.CarType = "备案车"
									if person, in := personMap[personId]; in {
										su.Username = person.PersonName
										su.PhoneNum = person.PhoneNo
									}
								} else {
									su.CarType = "临时车"
								}
							} else {
								su.PlateNo = "无车牌"
							}

							if isSuper {
								resultList = append(resultList, su)
							} else {
								if isSpaceShow(vipPlateNoArr, su.PlateNo) {
									resultList = append(resultList, su)
								}
							}

						}
					}
				}
			}
		}
	}

	sort.Sort(resultList)
	return resultList
}

func getVipPlateNoArr() []string {
	var vipPlateNoArr []string
	vipArr := strings.Split(beego.AppConfig.String("nightVipPlateNos"), ",")
	if vipArr != nil && len(vipArr) >0 {
		for _,po := range vipArr {
			if po != "" {
				cnPo := preDealPlateNo(po)
				if cnPo != "" {
					vipPlateNoArr = append(vipPlateNoArr, cnPo)
				}
			}
		}
	}
	return vipPlateNoArr
}

//白天和夜晚管理员都看不到vip车辆
func isSpaceShow(vipPlateNoArr []string, spacePto string) bool {
	if vipPlateNoArr != nil && len(vipPlateNoArr) >0 {
		targetPto := preDealPlateNo(spacePto)
		if isVipCar(targetPto, vipPlateNoArr) { //是vip车辆
			return false
		}
	}

	return true
}

func (sv *CarService) FindSpaceNo(userId string) models.PosResult {
	resultList := make(models.PosResult,0)
	var myPlateNosMap = make(map[string]string)
	if userId !="" {
		vehicles := sv.GetVehicleListByPerson(userId)
		if vehicles != nil {
			for _,veh := range vehicles {
				if veh.PlateNo != "" {
					r := []rune(veh.PlateNo)
					ncStr := string(r[1:]) //把第一位汉字剔除掉
					myPlateNosMap[ncStr] = ncStr
				}
				//myPlateNosMap[veh.PlateNo] = veh.PlateNo
			}
		}
	}

	url := "/artemis/api/pms/v1/parkingSpace/spaceNo"

	reqBody := map[string]interface{} {
		//"parkSyscode": p.ParkIndexCode,//停车库唯一标识
		//"state": 1, //车位状态，0：空闲，1：停车
		//"bindCars": bindCars,
		"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
		}
		vipPlateNoArr := getVipPlateNoArr()
		for _,s := range spaceList {
			pi := models.PosInfo {
				SpaceNo: s.SpaceNo,
				PosNo: "",
				State: s.State,
			}
			if s.PlateNo != "" {
				pi.PlateNo = s.PlateNo
			} else if s.PlateNos != "" {
				pi.PlateNo = s.PlateNos
			}
			pi.IsMine = isMyPlateNo(myPlateNosMap, pi.PlateNo)
			if v,ok := models.SpaceNo2Pos[s.SpaceNo];ok {
				pi.PosNo = v
			}
			if pi.IsMine || isSpaceShow(vipPlateNoArr, pi.PlateNo) {
				resultList = append(resultList, pi)
			} else {
				pi.State = 0
				pi.PlateNo = ""
				resultList = append(resultList, pi)
			}
		}
	}
	if len(resultList) == 0 {
		for i:=1;i<91;i++ {
			pi := models.PosInfo {
				SpaceNo: strconv.Itoa(i),
				PosNo: "",
				State: 1,
				PlateNo: "",
				IsMine: false,
			}
			resultList = append(resultList, pi)
		}
	}

	return resultList
}

//判断是不是自己的车牌号
//1.目前有误识别的问题，会把D识别成0,D和0不分
//2.汉字误识别的几率比较高
func isMyPlateNo(plateNoM map[string]string, targetPlateNo string) bool {
	if targetPlateNo != "" {
		r := []rune(targetPlateNo)
		nctPlateNo := string(r[1:])

		if _,exist := plateNoM[nctPlateNo];exist {
			return true
		} else {
			match := false
			for k,_ := range plateNoM {
				newK := strings.ReplaceAll(k, "D", "*")
				newK = strings.ReplaceAll(newK, "0", "*")

				tt := strings.ReplaceAll(nctPlateNo,"D", "*")
				tt = strings.ReplaceAll(tt,"0", "*")
				if newK == tt {
					match = true
					break
				}
			}
			return match
		}
	}
	return false
}

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

//以人员id为key
func (sv *CarService) GetHikPersonMap() map[string]HikPerson {
	m := make(map[string]HikPerson)
	personList := sv.GetHikPersonList()
	if personList != nil {
		for _,p := range personList {
			m[p.PersonId] = p
		}
	}
	return m
}

//以车牌号为Key
func (sv *CarService) GetHikVehicleMap() map[string] HikVehicle {
	m := make(map[string]HikVehicle)
	carPersons := sv.GetVehicleListByPerson("")
	if carPersons != nil {
		for _,veh := range carPersons {
			if veh.PlateNo != "" {
				r := []rune(veh.PlateNo)
				ncStr := string(r[1:]) //把第一位汉字剔除掉
				newK := strings.ReplaceAll(ncStr, "D", "*")
				newK = strings.ReplaceAll(newK, "0", "*")
				m[newK] = veh
			}
		}
	}

	return m
}

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 SyncHikPerson() int {
	syncCount := 0
	sv := NewCarService()
	hikPersons := sv.GetHikPersonList()
	if hikPersons != nil && len(hikPersons) >0 {
		var u models.User
		idMap := u.GetAllMap()
		hikPM := make(map[string]string)
		for _,hp := range hikPersons {
			hikPM[hp.PersonId] = hp.PhoneNo
			if sp,ok := idMap[hp.PersonId];ok {
				if sp.PhoneNum != hp.PhoneNo {
					u.UpdatePhoneNum(hp.PhoneNo, hp.PersonId)
					syncCount++
				}
			}
		}
		for k,_ := range idMap {
			if _,in := hikPM[k];!in {
				u.Delete(k)
				syncCount++
			}
		}

	}
	return syncCount
}

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": 1000,
	}
	if personId != "" {
		reqBody["personIds"] = personId
	}
	pageResult := sv.getHikPageResult(url, reqBody)
	if pageResult ==nil {
		fmt.Println("GetVehicleListByPerson pageResult is 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
		} else {
			fmt.Println("unmarshal err:", err)
		}
	}

	return nil
}

//过车记录
type CrossRecord struct {
	CrossRecordSyscode 			string  		`json:"crossRecordSyscode"`
	parkSyscode        			string  		`json:"parkSyscode"`
	ParkName           			string  		`json:"parkName"`
	EntranceSyscode    			string  		`json:"entranceSyscode"`
	EntranceName       			string  		`json:"entranceName"`
	RoadwaySyscode     			string  		`json:"roadwaySyscode"`
	RoadwayName        			string  		`json:"roadwayName"`
	VehicleOut         			int  			`json:"vehicleOut"`
	ReleaseMode        			int  			`json:"releaseMode"`
	ReleaseResult      			int  			`json:"releaseResult"`
	ReleaseWay         			int  			`json:"releaseWay"`
	ReleaseReason      			int  			`json:"releaseReason"`
	PlateNo            			string  		`json:"plateNo"`
	CardNo             			string  		`json:"cardNo"`
	//VehicleColor     			int    			`json:"vehicleColor"`
	//VehicleType      			int    			`json:"vehicleType"`
	//PlateColor       			int    			`json:"plateColor"`
	//PlateType        			int    			`json:"plateType"`
	//CarCategory      			string    		`json:"carCategory"`
	//CarCategoryName  			string    		`json:"carCategoryName"`
	VehiclePicUri      			string  		`json:"vehiclePicUri"`
	PlateNoPicUri      			string  		`json:"plateNoPicUri"`
	FacePicUri         			string  		`json:"facePicUri"`
	AswSyscode         			string  		`json:"aswSyscode"`
	CrossTime          			string  		`json:"crossTime"`
	CreateTime         			string  		`json:"createTime"`
}

func (sv *CarService) CrossRecords() []CrossRecord {
	url := "/artemis/api/pms/v1/crossRecords/page"
	reqBody := map[string]interface{} {
		"pageNo": 1,
		"pageSize": 100,
	}
	pageResult := sv.getHikPageResult(url, reqBody)
	if pageResult ==nil {
		return nil
	}
	b, err := json.Marshal(pageResult.List)
	if err == nil {
		var list []CrossRecord
		if err = json.Unmarshal(b, &list);err == nil {
			return list
		}
	}

	return nil
}