package handler

import (
	"io"
	"jirasop/model"
	"jirasop/pkg/analyzer"
	"jirasop/pkg/analyzer/emit"
	"jirasop/pkg/infra/cliniccli"
	"jirasop/pkg/infra/config"
	"jirasop/pkg/infra/jiracli"

	"jirasop/pkg/infra/log"

	"github.com/andygrunwald/go-jira"
	"github.com/gin-gonic/gin"
	"github.com/go-logr/logr"
)

type AnalyzeHandler struct {
	analyzerMap map[string]analyzer.Analyzer
	logger      logr.Logger
	jiraCli     *jiracli.JiraClient
}

func (ah *AnalyzeHandler) jiraEventHandler() func(*gin.Context) {
	return func(ctx *gin.Context) {
		var jiraWebhookEvent model.JiraWebhookEvent
		err := ctx.ShouldBindJSON(&jiraWebhookEvent)
		if err != nil {
			ah.logger.Error(err, "fail to unmarshal webhook event")
			return
		}
		summary := jiraWebhookEvent.Issue.Fields.Summary
		if analyzer, exist := ah.analyzerMap[summary]; exist {
			ah.logger.Info("find analyzer", "event", summary, "analyzer", analyzer)
			res, err := analyzer.AnalyzeIssue(&jiraWebhookEvent)
			if err != nil {
				ah.logger.Error(err, "fail to analyze issue", "issue key", jiraWebhookEvent.Issue.Key)
			}
			emitStr, err := emit.Emit(res, summary)
			log.Logger.Info("string to emit", "emit string", emitStr)
			if err != nil {
				ah.logger.Error(err, "fail to emit analyze result")
			}

			// jira client comment.
			comment := jira.Comment{Body: emitStr}
			_, resp, err := ah.jiraCli.Client.Issue.AddComment(jiraWebhookEvent.Issue.Key, &comment)
			if err != nil {
				content, _ := io.ReadAll(resp.Body)
				ah.logger.Error(err, "error when comment jira", "msg", string(content))
			}
		}
		ctx.Writer.Write([]byte("test aaa"))
	}
}

func NewAnalyzeHandler(r *gin.RouterGroup, config config.RootConfig) (*AnalyzeHandler, error) {
	a := &AnalyzeHandler{}

	logr := log.Logger.WithName("AnalyzeHandler")
	a.logger = logr

	analyzerMap := make(map[string]analyzer.Analyzer)

	clinicCli := cliniccli.NewClinicClient(config.Log, config.Clinic)
	jiraCli, err := jiracli.NewJiraCli(config.Log, config.Jira)
	if err != nil {
		logr.Error(err, "fail to init jira client")
	}
	a.jiraCli = jiraCli

	// register all analyzer.
	kubePersistentVolumeFillingUpAnalyzer :=
		analyzer.NewKubePersistentVolumeFillingUpAnalyzer(config.Log, config.Anaylze[`[PROD]KubePersistentVolumeFillingUp`], clinicCli)
	analyzerMap[`[PROD]KubePersistentVolumeFillingUp`] = kubePersistentVolumeFillingUpAnalyzer

	a.analyzerMap = analyzerMap

	r.POST("/jirasop", a.jiraEventHandler())
	return a, nil
}