package service

import (
	"bytes"
	"city_chips/internal/model"
	"city_chips/internal/repository"
	"encoding/json"
	"errors"
	"github.com/spf13/viper"
	"io"
	"net/http"
)

type TemperatureService interface {
	temperature(method, url string, body any) ([]byte, error)
	GetStatistics() ([]byte, error)
	GetBaseecic(currentPage, device_type_id, devices_enabled, gateway_id, pageSize int, query, devices_udid string) (model.IlluminatingBaseecic, error)
	GetAlarm(currentPage, pageSize int) ([]byte, error)
	GetAlarmStatistics(start_time, end_time string) ([]byte, error)
	GetgatewayFind() (model.GatewayFind, error)
	GetDeviceStatistics() (model.CategoryStatistics, error)
	GetGatewayStatistics() (model.GatewayStatistics, error)
	DevicesControl(agreement_json, request_id, udid string, source int) (model.DevicesControl, error)
}

func NewTemperatureService(service *Service, temperatureRepository repository.TemperatureRepository, conf *viper.Viper, client *http.Client) TemperatureService {
	return &temperatureService{
		Service:               service,
		temperatureRepository: temperatureRepository,
		conf:                  conf,
		client:                client,
	}
}

type temperatureService struct {
	*Service
	temperatureRepository repository.TemperatureRepository
	conf                  *viper.Viper
	client                *http.Client
}

func (s *temperatureService) temperature(method, url string, body any) ([]byte, error) {
	login, err := s.login()
	if err != nil {
		return nil, err
	}

	var reqBody io.Reader
	var finalURL = url

	// 如果是 GET 请求，把 body 当作 query 参数处理
	if method == http.MethodGet || method == "" {
		vals, err := buildQueryParams(body)
		if err != nil {
			return nil, err
		}
		finalURL = addQueryParams(url, vals)
	} else {
		// 非 GET 请求才构造 body
		reqBody, err = buildRequestBody(body)
		if err != nil {
			return nil, err
		}
	}

	request, err := http.NewRequest(method, finalURL, reqBody)
	if err != nil {
		return nil, err
	}
	request.Header.Set("Authorization", login.AccessToken)

	response, err := s.client.Do(request)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	respBody, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, err
	}
	return respBody, nil
}

// login 封装登录逻辑
func (s *temperatureService) login() (*model.Login, error) {
	auth := s.conf.GetString("temperature.authorization")
	clientId := s.conf.GetInt("temperature.clientId")
	mobile := s.conf.GetString("temperature.mobile")
	password := s.conf.GetString("temperature.password")

	loginReq := model.LoginRequst{
		Authorization: auth,
		ClientId:      clientId,
		Mobile:        mobile,
		Password:      password,
	}

	bodyBytes, err := json.Marshal(loginReq)
	if err != nil {
		return nil, err
	}

	url := s.conf.GetString("temperature.baseUrl") + s.conf.GetString("temperature.api.login")
	request, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyBytes))
	if err != nil {
		return nil, err
	}

	response, err := s.client.Do(request)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	respBody, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, err
	}

	var login model.Login
	if err := json.Unmarshal(respBody, &login); err != nil {
		return nil, err
	}

	return &login, nil
}

// GetStatistics 获取统计信息
func (s *temperatureService) GetStatistics() ([]byte, error) {
	urls := s.conf.GetString("temperature.baseUrl") + s.conf.GetString("temperature.api.statistics")
	temperature, err := s.temperature("GET", urls, nil)
	if err != nil {
		return nil, errors.New("获取统计信息失败")
	}
	return temperature, nil
}

// GetDeviceStatistics 获取设备统计信息
func (s *temperatureService) GetDeviceStatistics() (model.CategoryStatistics, error) {
	var respone model.CategoryStatistics
	urls := s.conf.GetString("temperature.baseUrl") + s.conf.GetString("temperature.api.deviceStatistics")
	temperature, err := s.temperature("GET", urls, nil)
	if err != nil {
		return model.CategoryStatistics{}, errors.New("获取设备统计信息失败")
	}
	err = json.Unmarshal(temperature, &respone)
	if err != nil {
		return model.CategoryStatistics{}, errors.New("json反序列化失败")
	}
	return respone, nil
}

// GetGatewayStatistics 网关设备在线离线统计
func (s *temperatureService) GetGatewayStatistics() (model.GatewayStatistics, error) {
	var respone model.GatewayStatistics
	urls := s.conf.GetString("temperature.baseUrl") + s.conf.GetString("temperature.api.gatewayStatistics")
	temperature, err := s.temperature("GET", urls, nil)
	if err != nil {
		return model.GatewayStatistics{}, errors.New("获取设备统计信息失败")
	}
	err = json.Unmarshal(temperature, &respone)
	if err != nil {
		return model.GatewayStatistics{}, errors.New("json反序列化失败")
	}
	return respone, nil
}

// GetAlarm 获取报警信息
func (s *temperatureService) GetAlarm(currentPage, pageSize int) ([]byte, error) {
	urls := s.conf.GetString("temperature.baseUrl") + s.conf.GetString("temperature.api.alarm")
	m := make(map[string]any)
	m["currentPage"] = currentPage
	m["pageSize"] = pageSize
	temperature, err := s.temperature("POST", urls, m)
	if err != nil {
		return nil, errors.New("获取统计信息失败")
	}
	return temperature, nil
}

// GetAlarmStatistics 获取报警统计信息
func (s *temperatureService) GetAlarmStatistics(start_time, end_time string) ([]byte, error) {
	urls := s.conf.GetString("temperature.baseUrl") + s.conf.GetString("temperature.api.alarmStatistics")
	urls += "?start_time=" + start_time + "&end_time=" + end_time
	temperature, err := s.temperature("GET", urls, nil)
	if err != nil {
		return nil, errors.New("获取统计信息失败")
	}
	return temperature, nil
}

// GetBaseecic 获取温控面板列表
func (s *temperatureService) GetBaseecic(currentPage, device_type_id, devices_enabled, gateway_id, pageSize int, query, devices_udid string) (model.IlluminatingBaseecic, error) {
	var baseecic model.IlluminatingBaseecic
	urls := s.conf.GetString("temperature.baseUrl") + s.conf.GetString("temperature.api.baseecic")
	m := make(map[string]any)
	m["currentPage"] = currentPage
	m["pageSize"] = pageSize

	if currentPage == 0 {
		m["currentPage"] = 1
	}
	if pageSize == 0 {
		m["pageSize"] = 20
	}
	if device_type_id != 0 {
		m["device_type_id"] = device_type_id
	}
	if devices_enabled != 0 {
		m["devices_enabled"] = devices_enabled
	}
	if gateway_id != 0 {
		m["gateway_id"] = gateway_id
	}
	if devices_udid != "" {
		m["devices_udid"] = devices_udid
	}
	if query != "" {
		m["query"] = query
	}
	temperature, err := s.temperature("POST", urls, m)
	if err != nil {
		return model.IlluminatingBaseecic{}, errors.New("获取统计信息失败")
	}
	err = json.Unmarshal(temperature, &baseecic)
	if err != nil {
		return model.IlluminatingBaseecic{}, errors.New("json反序列化失败")
	}
	return baseecic, nil
}

// GetgatewayFind 获取网关列表
func (s *temperatureService) GetgatewayFind() (model.GatewayFind, error) {
	var gateway model.GatewayFind
	urls := s.conf.GetString("temperature.baseUrl") + s.conf.GetString("temperature.api.gatewayFind")
	m := make(map[string]any)
	m["gateway_type"] = -1

	temperature, err := s.temperature("POST", urls, m)
	if err != nil {
		return model.GatewayFind{}, errors.New("获取统计信息失败")
	}
	err = json.Unmarshal(temperature, &gateway)
	if err != nil {
		return model.GatewayFind{}, errors.New("json反序列化失败")
	}
	return gateway, nil
}
func (s *temperatureService) DevicesControl(agreement_json, request_id, udid string, source int) (model.DevicesControl, error) {
	var devicesControl model.DevicesControl
	urls := s.conf.GetString("illuminating.baseUrl") + s.conf.GetString("temperature.api.devicesControl")
	m := make(map[string]any)
	m["agreement_json"] = agreement_json
	if request_id != "" {
		m["request_id"] = request_id
	}
	m["source"] = source
	m["udid"] = udid

	illuminating, err := s.temperature("POST", urls, m)
	if err != nil {
		return model.DevicesControl{}, errors.New("控制空调设备失败")
	}
	err = json.Unmarshal(illuminating, &devicesControl)
	if err != nil {
		return model.DevicesControl{}, errors.New("json反序列化失败")
	}

	return devicesControl, nil
}