package api

import (
	"easyvqd/internal/conf"
	"easyvqd/internal/core/host"
	"easyvqd/internal/core/media"
	"easyvqd/internal/core/vqd"
	"easyvqd/internal/core/vqdtask"
	"fmt"
	"git.lnton.com/lnton/pkg/reason"
	"github.com/gin-gonic/gin"
	"github.com/ixugo/goddd/pkg/web"
	"strconv"
)

type VqdTaskAPI struct {
	core       *vqd.Core
	meidaCore  *media.Core
	vqdSdkCore *vqdtask.Core
	cfg        *conf.Bootstrap
	HostCore   *host.Core
}

func NewVqdTaskAPI(core *vqd.Core, meidaCore *media.Core, vqdSdkCore *vqdtask.Core, HostCore *host.Core, cfg *conf.Bootstrap) VqdTaskAPI {
	return VqdTaskAPI{core: core, meidaCore: meidaCore, vqdSdkCore: vqdSdkCore, HostCore: HostCore, cfg: cfg}
}

func RegisterVqdTask(g gin.IRouter, api VqdTaskAPI, handler ...gin.HandlerFunc) {
	{

		groupTask := g.Group("/api/task", handler...)
		groupTask.GET("", web.WarpH(api.findVqdTask))
		groupTask.GET("/:id", web.WarpH(api.getVqdTask))
		groupTask.PUT("/:id", web.WarpH(api.editVqdTask))
		groupTask.POST("", web.WarpH(api.addVqdTask))
		groupTask.DELETE("/:id", web.WarpH(api.delVqdTask))

		groupTemplate := g.Group("/api/template", handler...)
		groupTemplate.GET("", web.WarpH(api.findVqdTaskTemplate))
		groupTemplate.GET("/:id", web.WarpH(api.getVqdTaskTemplate))
		groupTemplate.PUT("/:id", web.WarpH(api.editVqdTaskTemplate))
		groupTemplate.POST("", web.WarpH(api.addVqdTaskTemplate))
		groupTemplate.DELETE("/:id", web.WarpH(api.delVqdTaskTemplate))

		groupTime := g.Group("/api/plan", handler...)
		groupTime.GET("", web.WarpH(api.findVqdTimeTemplate))
		groupTime.GET("/:id", web.WarpH(api.getVqdTimeTemplate))
		groupTime.PUT("/:id", web.WarpH(api.editVqdTimeTemplate))
		groupTime.POST("", web.WarpH(api.addVqdTimeTemplate))
		groupTime.DELETE("/:id", web.WarpH(api.delVqdTimeTemplate))

		groupAlarm := g.Group("/api/alarm", handler...)
		groupAlarm.GET("", web.WarpH(api.findVqdAlarm))
		groupAlarm.GET("/:id", web.WarpH(api.getVqdAlarm))
		groupAlarm.DELETE("/:id", web.WarpH(api.delVqdAlarm))
		groupAlarm.DELETE("", web.WarpH(api.delVqdAlarmAll))

	}
}

func (a VqdTaskAPI) findVqdTask(c *gin.Context, in *vqd.FindVqdTaskInput) (any, error) {
	items, total, err := a.core.FindVqdTask(c.Request.Context(), in)
	rows := make([]map[string]interface{}, 0)

	for _, item := range items {
		//row := structs.Map(item)
		row := make(map[string]interface{})
		row["name"] = item.Name
		row["id"] = item.ID
		row["enable"] = item.Enable
		row["channel_id"] = item.ChannelID
		row["channel_name"] = item.ChannelName
		row["task_template_id"] = item.TaskTemplateID
		row["time_template_id"] = item.TimeTemplateID
		row["task_template_name"] = ""
		row["time_template_name"] = ""
		template, errs := a.core.GetIDVqdTaskTemplate(c.Request.Context(), item.TaskTemplateID)
		if errs == nil && template != nil {
			row["task_template_name"] = template.Name
		}
		timeTemplate, errs := a.core.GetIDVqdTimeTemplate(c.Request.Context(), item.TimeTemplateID)
		if errs == nil && template != nil {
			row["time_template_name"] = timeTemplate.Name
		}
		row["error_msg"] = ""
		row["status"] = 0
		v, ok := vqdtask.VqdTaskMap.LoadTaskMap(item.ChannelID)
		if ok {
			row["error_msg"] = v.ErrorMsg
			row["status"] = v.Status
		}
		row["created_at"] = item.CreatedAt
		row["updated_at"] = item.UpdatedAt

		rows = append(rows, row)
	}

	return gin.H{"items": rows, "total": total}, err
}
func (a VqdTaskAPI) getVqdTask(c *gin.Context, _ *struct{}) (any, error) {
	ID, _ := strconv.Atoi(c.Param("id"))
	item, err := a.core.GetVqdTask(c.Request.Context(), ID)
	if err != nil {
		return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`find vqdcms [%d] err [%s]`, ID, err.Error()))
	}
	row := make(map[string]interface{})

	row["name"] = item.Name
	row["id"] = item.ID
	row["enable"] = item.Enable
	row["channel_id"] = item.ChannelID
	row["channel_name"] = item.ChannelName
	row["task_template_id"] = item.TaskTemplateID
	row["time_template_id"] = item.TimeTemplateID
	row["task_template_name"] = ""
	row["time_template_name"] = ""
	template, errs := a.core.GetIDVqdTaskTemplate(c.Request.Context(), item.TaskTemplateID)
	if errs == nil && template != nil {
		row["task_template_name"] = template.Name
	}
	timeTemplate, errs := a.core.GetIDVqdTimeTemplate(c.Request.Context(), item.TimeTemplateID)
	if errs == nil && template != nil {
		row["time_template_name"] = timeTemplate.Name
	}
	row["error_msg"] = ""
	row["status"] = 0
	v, ok := vqdtask.VqdTaskMap.LoadTaskMap(item.ChannelID)
	if ok {
		row["error_msg"] = v.ErrorMsg
		row["status"] = v.Status
	}
	row["created_at"] = item.CreatedAt
	row["updated_at"] = item.UpdatedAt

	row["des"] = item.Des
	return gin.H{"data": row}, err
}
func (a VqdTaskAPI) addVqdTask(c *gin.Context, in *vqd.AddVqdTaskInput) (any, error) {
	taskChn, err := a.core.GetNameVqdTaskChannelID(c.Request.Context(), in.ChannelID)
	if err == nil && taskChn != nil {
		return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`通道任务已存在 [%s] `, taskChn.ChannelID))
	}

	task, err := a.core.AddVqdTask(c.Request.Context(), in)
	if err != nil {
		return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`add vqdcms err [%s]`, err.Error()))
	}
	err = a.vqdSdkCore.AddTaskVqd(task.ID)
	if err != nil {
		return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`add task err [%s]`, err.Error()))
	}
	return gin.H{"data": "OK!"}, err
}

func (a VqdTaskAPI) editVqdTask(c *gin.Context, in *vqd.EditVqdTaskInput) (any, error) {
	ID, _ := strconv.Atoi(c.Param("id"))
	task, err := a.core.GetVqdTask(c.Request.Context(), ID)
	if err != nil {
		return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`find vqdcms [%d] err [%s]`, ID, err.Error()))
	}
	if task.ChannelID != in.ChannelID {
		taskChn, errs := a.core.GetNameVqdTaskChannelID(c.Request.Context(), in.ChannelID)
		if errs == nil && taskChn != nil {
			return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`通道任务已存在 [%s] `, taskChn.ChannelID))
		}
	}
	info, err := a.core.EditVqdTask(c.Request.Context(), in, ID)
	if err != nil {
		return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`edit vqdcms err [%s]`, err.Error()))
	}
	if task.Enable == false && in.Enable {
		err = a.vqdSdkCore.AddTaskVqd(task.ID)
		if err != nil {
			return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`add task err [%s]`, err.Error()))
		}
	} else {
		if info.Enable {
			err = a.vqdSdkCore.UpdateTaskVqd(ID)
			if err != nil {
				return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`update task err [%s]`, err.Error()))
			}
		} else {
			a.vqdSdkCore.DelTaskVqd(ID, info.ChannelID)
		}
	}
	return gin.H{"data": "OK!"}, err
}

func (a VqdTaskAPI) delVqdTask(c *gin.Context, _ *struct{}) (any, error) {
	ID, _ := strconv.Atoi(c.Param("id"))
	task, err := a.core.DelVqdTask(c.Request.Context(), ID)
	if err != nil {
		return nil, reason.ErrServer.SetMsg(fmt.Sprintf(`del vqdcms [%d] err [%s]`, ID, err.Error()))
	}
	a.vqdSdkCore.DelTaskVqd(ID, task.ChannelID)
	return gin.H{"data": "OK!"}, err
}