package xphapi

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"strconv"
	"strings"
	"time"
)

type Xph struct {
	baseUrl string
	back    map[int][]Entity
}

func NewXphObject(baseUrl string) *Xph {
	return &Xph{
		baseUrl: baseUrl,
		back:    make(map[int][]Entity),
	}
}

// NewGetToken 获取token
func (x *Xph) GetToken(username, password string) string {
	// 超时时间：5秒
	client := &http.Client{Timeout: 5 * time.Second}
	loginParam := map[string]string{"username": username, "password": password}
	jsonStr, _ := json.Marshal(loginParam)
	resp, err := client.Post(x.baseUrl+"/login", "application/json", bytes.NewBuffer(jsonStr))
	if err != nil {
		fmt.Print(err)
		return ""
	}
	defer resp.Body.Close()

	result, _ := ioutil.ReadAll(resp.Body)
	var token Token
	_ = json.Unmarshal(result, &token)
	return token.Token
}

// NewGetDevices 获取设备ID
func (x *Xph) GetDevices(username, token string) []Device {
	client := &http.Client{Timeout: 5 * time.Second}
	req, err := http.NewRequest("GET", x.baseUrl+"/user/"+username, nil)
	if err != nil {
		return nil
	}
	req.Header.Set("token", token)
	resp, err := client.Do(req)
	if err != nil {
		return nil
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	var user User
	_ = json.Unmarshal(body, &user)
	return user.Devices
}

// NewGetDevices 获取设备ID, 包括虫情
func (x *Xph) GetAllDevices(username, token string) []CommonDevice {
	client := &http.Client{Timeout: 5 * time.Second}
	req, err := http.NewRequest("GET", x.baseUrl+"/user/"+username, nil)
	if err != nil {
		return nil
	}
	req.Header.Set("token", token)
	resp, err := client.Do(req)
	if err != nil {
		return nil
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	var user User
	_ = json.Unmarshal(body, &user)

	var devs []CommonDevice
	devs = append(devs, user.Pests...)
	for _, device := range user.Devices {
		dev := CommonDevice{
			DeviceID:     strconv.Itoa(device.DeviceID),
			DeviceName:   device.DeviceName,
			DeviceRemark: device.DeviceRemark,
			SIM:          device.SIM,
		}
		devs = append(devs, dev)
	}
	return devs
}

func ProcessAbnormalData(entities []Entity, back []Entity) {
	for index, entity := range entities {
		value := strings.Split(entity.EValue, ".")
		v := strings.Join(value, "")
		if v == "32767" {
			entities[index] = back[index]
		}
	}
	copy(back, entities)
}
func (x *Xph) GetDeviceRealData(facId int) (DataEntity, error) {
	var dataEntity DataEntity
	resp, err := http.Get(x.baseUrl + "/intfa/queryData/" + strconv.Itoa(facId))
	if err != nil {
		return dataEntity, errors.New("获取实时数据异常：" + err.Error())
	}
	result, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return dataEntity, errors.New("读取响应 body异常：" + err.Error())
	}
	err = json.Unmarshal(result, &dataEntity)
	if err != nil {
		return dataEntity, errors.New("解析响应 body异常：" + err.Error())
	}

	if len(x.back[facId]) == 0 {
		x.back[facId] = make([]Entity, 32)
		copy(x.back[facId], dataEntity.Entity)
	}
	ProcessAbnormalData(dataEntity.Entity, x.back[facId])

	return dataEntity, err
}
func (x *Xph) GetDeviceRealState(facId int) (CurrentData, error) {
	var data CurrentData

	resp, err := http.Get(x.baseUrl + "/data/" + strconv.Itoa(facId))
	if err != nil {
		return data, errors.New("获取实时数据异常：" + err.Error())
	}
	result, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return data, errors.New("读取响应 body异常：" + err.Error())
	}
	err = json.Unmarshal(result, &data)
	if err != nil {
		return data, errors.New("解析响应 body异常：" + err.Error())
	}

	return data, err
}

func (x *Xph) PostControlRelay(id, index, state int, token string) (bool, error) {
	client := &http.Client{Timeout: 30 * time.Second}
	relayParam := map[string]int{"deviceId": id, "relayNum": index, "relayState": state}
	jsonStr, _ := json.Marshal(relayParam)
	req, err := http.NewRequest("POST", x.baseUrl+"/relay", bytes.NewBuffer(jsonStr))
	if err != nil {
		return false, err
	}
	req.Header.Set("token", token)
	req.Header.Set("Content-Type", "application/json")
	resp, err := client.Do(req)
	if err != nil {
		return false, err
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)

	return string(body) == "true", nil
}

func (x *Xph) GetDeviceData(id, token string) (data DeviceData, err error) {
	client := &http.Client{Timeout: 5 * time.Second}
	req, err := http.NewRequest("GET", x.baseUrl+"/screen/datas?deviceId="+id, nil)
	if err != nil {
		return
	}
	req.Header.Set("token", token)
	req.Header.Set("content-type", "application/x-www-form-urlencoded")
	resp, err := client.Do(req)
	if err != nil {
		return
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	err = json.Unmarshal(body, &data)

	return
}

type PestImageRespond struct {
	DataTime    string `json:"dataTime"`
	Image       string `json:"image"`
	Imei        string `json:"imei"`
	Result      string `json:"result"`
	ResultImage string `json:"resultImage"`
}

func (x *Xph) GetPestImage(id, token string) (image PestImageRespond, err error) {
	client := &http.Client{Timeout: 5 * time.Second}
	req, err := http.NewRequest("GET", x.baseUrl+"/pest/image/"+id, nil)
	if err != nil {
		return
	}
	req.Header.Set("token", token)
	req.Header.Set("content-type", "application/x-www-form-urlencoded")
	resp, err := client.Do(req)
	if err != nil {
		return
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	err = json.Unmarshal(body, &image)

	return
}