package controller

import (
	"electricity_bill_calc/logger"
	"electricity_bill_calc/model"
	"electricity_bill_calc/repository"
	"electricity_bill_calc/response"
	"electricity_bill_calc/security"
	"electricity_bill_calc/service"
	"electricity_bill_calc/tools"
	"electricity_bill_calc/vo"
	"fmt"
	"github.com/gofiber/fiber/v2"
	"go.uber.org/zap"
)

var synchronizeLog = logger.Named("Handler", "Synchronize")

func InitializeSynchronizeHandlers(router *fiber.App) {
	router.Get("/synchronize/task", security.EnterpriseAuthorize, searchSynchronizeSchedules)
	router.Get("/synchronize/configuration", security.EnterpriseAuthorize, getSynchronizeConfiguration)
	router.Post("/synchronize/configuration", security.EnterpriseAuthorize, recordsynchronizeConfiguration)
}

// 查询当前平台中符合查询条件的同步任务，企业用户无论传入什么用户ID条件，都仅能看到自己的同步任务
func searchSynchronizeSchedules(c *fiber.Ctx) error {
	result := response.NewResult(c)
	session, err := _retreiveSession(c)
	if err != nil {
		synchronizeLog.Error("查询同步任务失败，未能获取当前用户会话信息", zap.Error(err))
		return result.Unauthorized("未能获取当前用户会话信息。")
	}
	parkId := tools.EmptyToNil(c.Params("park"))
	if parkId != nil && len(*parkId) > 0 {
		if pass, err := checkParkBelongs(*parkId, reportLog, c, &result); !pass {
			return err
		}
	}
	userId := tools.EmptyToNil(c.Params("user"))
	keyword := tools.EmptyToNil(c.Query("keyword"))
	page := c.QueryInt("page", 1)
	synchronizeLog.Info("查询当前平台中符合查询条件的同步任务。", zap.String("Ent", session.Uid), zap.Stringp("Park", parkId))
	schedules, total, err := repository.SynchronizeRepository.SearchSynchronizeSchedules(userId, parkId, uint(page), keyword)
	if err != nil {
		reportLog.Error("无法获取同步任务", zap.Error(err))
		return result.Error(fiber.StatusInternalServerError, "无法获取同步任务")
	}
	return result.Success(
		" ",
		response.NewPagedResponse(page, total).ToMap(),
		fiber.Map{"tasks": schedules},
	)
}

// 获取指定的同步任务配置
func getSynchronizeConfiguration(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Query("park")
	userId := c.Query("user")
	session, err := _retreiveSession(c)
	if err != nil {
		reportLog.Error("无法获取当前用户的会话信息", zap.Error(err))
		return result.Unauthorized("无法获取当前用户的会话信息。")
	}
	var user_id string
	if session.Type == model.USER_TYPE_ENT {
		user_id = session.Uid
	} else {
		if userId != "" {
			user_id = userId
		} else {
			return result.NotAccept(fmt.Sprintf("必须指定要记录同步任务的用户,%s", err.Error()))
		}
	}
	fmt.Println("pppppppppppppppppppppppppppp", parkId, len(parkId))
	if parkId == "" {
		return result.NotAccept("必须指定要获取同步任务的园区。")
	}

	fmt.Printf(user_id)
	configurations, err := repository.SynchronizeRepository.RetrieveSynchronizeConfiguration(user_id, parkId)
	if err != nil {
		reportLog.Error("无法获取同步任务", zap.Error(err))
		return result.Error(fiber.StatusInternalServerError, "无法获取同步任务")
	}
	return result.Success(
		" 123",
		fiber.Map{"setup": configurations},
	)
}
func recordsynchronizeConfiguration(c *fiber.Ctx) error {
	userId := c.Query("user")
	synchronizeLog.Info("记录一个新的同步任务配置", zap.String("user id", userId))
	session, err := _retreiveSession(c)
	result := response.NewResult(c)
	if err != nil {
		reportLog.Error("无法获取当前用户的会话信息", zap.Error(err))
		return result.Unauthorized("无法获取当前用户的会话信息。")
	}
	var Form vo.SynchronizeConfigurationCreateForm
	if err := c.BodyParser(&Form); err != nil {
		meterLog.Error("无法更新同步配置，无法解析表计更新表单", zap.Error(err))
		return result.NotAccept(err.Error())
	}
	var user_id string
	if session.Type == model.USER_TYPE_ENT {
		user_id = session.Uid
	} else {
		if userId != "" {
			user_id = userId
		} else {
			return result.NotAccept(fmt.Sprintf("必须指定更新同步任务的用户,%s", err.Error()))
		}
	}
	//configurations, err := repository.SynchronizeRepository.CreateSynchronizeConfiguration
	if err := service.SynchronizeService.CreateSynchronizeConfiguration(user_id, &Form); err != nil {
		synchronizeLog.Error("无法更新同步配置", zap.Error(err))
		return result.NotAccept(err.Error())
	}
	return result.Success("更新完成。")
}