package action

import (
	"fmt"
	"pbx-api-gin/internal/app/stc/priority"
	alstatus "pbx-api-gin/internal/app/stc/sendstatus"
	"pbx-api-gin/internal/pkg/configs"
	"pbx-api-gin/pkg/lfshook"
	"pbx-api-gin/pkg/utils"

	"github.com/sirupsen/logrus"
	"github.com/tqcenglish/amigo-go"
	"github.com/tqcenglish/amigo-go/pkg"
)

var AminInstance *amigo.Amigo
var trainInfo = ""

func HandleAMI(event map[string]string) {

	switch event["Event"] {

	case "UserEvent": // RCD filename; PA;CPA; CabCab
		//lfshook.NewLogger().Infof("========event:%s   File:%s", event["Event"], event["FILENAME"])
		if event["UserEvent"] == "CallType" && event["Type"] == "C2C" {

			if event["CallerIDNum"] == "9011" {
				Hangup("9071")
			} else if event["CallerIDNum"] == "9071" {
				Hangup("9011")
			}
		}

	case "QueueCallerJoin":
		lfshook.NewLogger().Infof("=========%s", event["Event"])

		resCaller, err := QueueStatus("0300", "")
		if err != nil {
			lfshook.NewLogger().Infof("QueueStatus err:%+v", err)
			return
		}

		if resCaller == nil {
			return
		}

		if resCaller.Entrys != nil {

			pads := ""
			count := 0
			for _, caller := range resCaller.Entrys {
				pads = fmt.Sprintf("%s%s&", pads, caller.CallerIDNum)
				count++
			}

			alstatus.SendQueueStatus(pads, count)
		}

	case "QueueCallerLeave":

		lfshook.NewLogger().Infof("=========%s", event["Event"])
		resCaller, err := QueueStatus("0300", "")
		if err != nil {
			lfshook.NewLogger().Infof("QueueStatus err:%+v", err)
			return
		}

		if resCaller == nil {
			return
		}

		if resCaller.Entrys != nil {

			pads := ""
			count := 0
			for _, caller := range resCaller.Entrys {
				pads = fmt.Sprintf("%s%s&", pads, caller.CallerIDNum)
				count++
			}

			alstatus.SendQueueStatus(pads, count)
		}

	case "ConfbridgeJoin":
		lfshook.NewLogger().Infof("=========%+v", event["Event"])
		//set priority and send PA status msg
		switch event["CallerIDName"] {
		case "PMC":
			if event["Exten"] == "0500" {
				//================================
				task := priority.TaskInfo{
					RunChannel:   event["Channel"],
					LocalChan:    event["Channel"],
					RunType:      "PMC",
					Priority:     priority.AllTasks.PMC.Priority,
					ConfbridgeID: event["Conference"],
					Running:      true,
				}
				utils.LoggerDebug.Printf("%s Runing , Set %s task info %+v .", event["CallerIDName"], event["CallerIDName"], task)
				priority.RegistryTask.Register("PMC", task)
				if priority.TaskCreating == "PMC" {
					utils.LoggerDebug.Printf("PMC Connected : Clean priority.TaskCreating = '' !")
					priority.TaskCreating = ""
				}

				alstatus.PaStatus("", "PMC", "start")

				return
			}

		case "PA":
			if event["Exten"] == "0501" {
				//================================
				task := priority.TaskInfo{
					RunChannel:   event["Channel"],
					LocalChan:    event["Channel"],
					RunType:      "PA",
					Priority:     priority.AllTasks.PA.Priority,
					ConfbridgeID: event["Conference"],
					Running:      true,
				}
				utils.LoggerDebug.Printf("%s Runing , Set %s task info %+v .", event["CallerIDName"], event["CallerIDName"], task)
				priority.RegistryTask.Register("PA", task)
				if priority.TaskCreating == "PA" {
					utils.LoggerDebug.Printf("PA Connected : Clean priority.TaskCreating = '' !")
					priority.TaskCreating = ""
				}

				alstatus.PaStatus("", "PA", "start")

				return
			}

		case "SVM":
			if event["Exten"] == "0502" {
				//================================
				task := priority.TaskInfo{
					RunChannel:   event["Channel"],
					LocalChan:    event["Channel"],
					RunType:      "SVM",
					Priority:     priority.AllTasks.SVM.Priority,
					ConfbridgeID: event["Conference"],
					Running:      true,
				}
				utils.LoggerDebug.Printf("%s Runing , Set %s task info %+v .", event["CallerIDName"], event["CallerIDName"], task)
				priority.RegistryTask.Register("SVM", task)
				if priority.TaskCreating == "SVM" {
					utils.LoggerDebug.Printf("SVM Connected : Clean priority.TaskCreating = '' !")
					priority.TaskCreating = ""
				}

				alstatus.PaStatus("", "SVM", "start")

				return
			}

		case "SVA":
			if event["Exten"] == "0503" {

				//================================
				task := priority.TaskInfo{
					RunChannel:   event["Channel"],
					LocalChan:    event["Channel"],
					RunType:      "SVA",
					Priority:     priority.AllTasks.SVA.Priority,
					ConfbridgeID: event["Conference"],
					Running:      true,
				}
				utils.LoggerDebug.Printf("%s Runing , Set %s task info %+v .", event["CallerIDName"], event["CallerIDName"], task)
				priority.RegistryTask.Register("SVA", task)
				alstatus.PaStatus("", "SVA", "start")
				if priority.TaskCreating == "SVA" {
					utils.LoggerDebug.Printf("SVA Connected : Clean priority.TaskCreating = '' !")
					priority.TaskCreating = ""
				}

				return
			}

		case "DCS":
			if event["Exten"] == "0504" {
				//================================
				task := priority.TaskInfo{
					RunChannel:   event["Channel"],
					LocalChan:    event["Channel"],
					RunType:      "DCS",
					Priority:     priority.AllTasks.DCS.Priority,
					ConfbridgeID: event["Conference"],
					Running:      true,
				}
				utils.LoggerDebug.Printf("%s Runing , Set %s task info %+v .", event["CallerIDName"], event["CallerIDName"], task)
				priority.RegistryTask.Register("DCS", task)
				alstatus.PaStatus("", "DCS", "start")
				if priority.TaskCreating == "DCS" {
					utils.LoggerDebug.Printf("DCS Connected : Clean priority.TaskCreating = '' !")
					priority.TaskCreating = ""
				}

				return
			}
		case "STNA":
			if event["Exten"] == "0505" {
				//================================
				task := priority.TaskInfo{
					RunChannel:   event["Channel"],
					LocalChan:    event["Channel"],
					RunType:      "STNA",
					Priority:     priority.AllTasks.STNA.Priority,
					ConfbridgeID: event["Conference"],
					Running:      true,
				}
				utils.LoggerDebug.Printf("%s Runing , Set %s task info %+v .", event["CallerIDName"], event["CallerIDName"], task)
				priority.RegistryTask.Register("STNA", task)
				alstatus.PaStatus("", "STNA", "start")
				if priority.TaskCreating == "STNA" {
					utils.LoggerDebug.Printf("STNA Connected : Clean priority.TaskCreating = '' !")
					priority.TaskCreating = ""
				}

				return
			}
		case "STNS":
			if event["Exten"] == "0506" {

				//================================
				task := priority.TaskInfo{
					RunChannel:   event["Channel"],
					LocalChan:    event["Channel"],
					RunType:      "STNS",
					Priority:     priority.AllTasks.STNS.Priority,
					ConfbridgeID: event["Conference"],
					Running:      true,
				}
				utils.LoggerDebug.Printf("%s Runing , Set %s task info %+v .", event["CallerIDName"], event["CallerIDName"], task)
				priority.RegistryTask.Register("STNS", task)
				alstatus.PaStatus("", "STNS", "start")
				if priority.TaskCreating == "STNS" {
					utils.LoggerDebug.Printf("CHSTNSK Connected : Clean priority.TaskCreating = '' !")
					priority.TaskCreating = ""
				}

				return
			}
		}

	case "ConfbridgeLeave":
		lfshook.NewLogger().Infof("=========%s", event["Event"])
		if utils.IsIO(event["CallerIDNum"]) && event["Exten"] == "0500" { // PMC end

			alstatus.PaStatus(event["CallerIDNum"], "PMC", "end")
			priority.RegistryTask.StopAndUnregister("PMC")

		} else if utils.IsICP(event["CallerIDNum"]) && event["Exten"] == "0501" { //PA end

			alstatus.PaStatus(event["CallerIDNum"], "PA", "end")
			priority.RegistryTask.StopAndUnregister("PA")

		} else if event["Exten"] == "0502" { // EMG broadcast hangup

			alstatus.PaStatus("", "SVM", "end")
			priority.RegistryTask.StopAndUnregister("SVM")

		} else if event["Exten"] == "0503" {

			alstatus.PaStatus("", "SVA", "end")
			priority.RegistryTask.StopAndUnregister("SVA")

		} else if event["Exten"] == "0504" {

			alstatus.PaStatus("", "DCS", "end")
			priority.RegistryTask.StopAndUnregister("DCS")

		} else if event["Exten"] == "0505" {

			alstatus.PaStatus("", "STNA", "end")
			priority.RegistryTask.StopAndUnregister("STNA")

		} else if event["Exten"] == "0506" {

			alstatus.PaStatus("", "STNS", "end")
			priority.RegistryTask.StopAndUnregister("STNS")

		}

	case "ExtensionStatus":
		//lfshook.NewLogger().Infof("=========event:%s  Ext:%s status:%s ", event["Event"], event["Exten"], event["StatusText"])

		//update PAD status
		if len(event["Exten"]) > 3 && utils.IsPAIU(event["Exten"]) {
			if event["StatusText"] == "Idle" || event["StatusText"] == "Unavailable" {
				alstatus.AlarmStatus(event["Exten"], event["StatusText"]) // PAD idle + unavailable
			}
		}

		//update ICP status
		if len(event["Exten"]) > 3 && utils.IsICP(event["Exten"]) {
			if event["StatusText"] == "Idle" || event["StatusText"] == "Unavailable" {
				alstatus.SendICPStatus(event["Exten"], event["StatusText"]) // PAD idle + unavailable
			}
		}
	}
}

func StartAMI(connectOKCallBack func(), handleEvents []func(event map[string]string)) {
	lfshook.NewLogger().Info("Start AMI")
	settings := &amigo.Settings{
		Host:     configs.ConfigGlobal.AsteriskAMIHost,
		Port:     configs.ConfigGlobal.AsteriskAMIPort,
		Username: configs.ConfigGlobal.AsteriskAMIUser,
		Password: configs.ConfigGlobal.AsteriskAMISecret,
		LogLevel: logrus.ErrorLevel}
	//lfshook.NewLogger().Infof("ami setting: %+v", settings)
	AminInstance = amigo.New(settings, lfshook.NewLogger())
	AminInstance.EventOn(func(payload ...interface{}) {
		// lfshook.NewLogger().Infof("ami event on %+v", payload[0])
		event := payload[0].(map[string]string)

		go HandleAMI(event)

		for _, handle := range handleEvents {
			go handle(event)
		}

	})
	AminInstance.ConnectOn(func(payload ...interface{}) {
		//lfshook.NewLogger().Infof("ami connect on %+v", payload[0])
		if payload[0] == pkg.Connect_OK {

			connectOKCallBack()
		} else {
			lfshook.NewLogger().Errorf("ami connect failure %+v", payload)
			//active.Master = false
		}
	})
	AminInstance.Connect()
}

func Connected() bool {
	if AminInstance != nil {
		return AminInstance.Connected()
	}
	return false
}