// Package handler provides HTTP handlers for various endpoints.
package handler

import (
	"context"
	"fmt"
	"net/http"
	"sync"

	"modelRT/constants"
	"modelRT/database"
	"modelRT/logger"
	"modelRT/network"

	"github.com/gin-gonic/gin"
	"github.com/gofrs/uuid"
	"gorm.io/gorm"
)

var globalMonitorState *SharedMonitorState

func init() {
	globalMonitorState = NewSharedMonitorState()
}

// RealTimeMonitorHandler define real time data monitor process API
// @Summary 开始或结束实时数据监控
// @Description 根据用户输入的组件token,从 modelRT 服务中开始或结束对于实时数据的监控
// @Tags RealTime Component
// @Accept json
// @Produce json
// @Param request body network.MeasurementRecommendRequest true "查询输入参数，例如 'trans' 或 'transformfeeder1_220.'"
// @Success 200 {object} network.SuccessResponse{payload=network.RealTimeMonitorPayload} "订阅实时数据结果列表"
//
//		@Example 200 {
//		    "code": 200,
//		    "msg": "success",
//		    "payload": {
//		        "targets": [
//		            {
//						"id": "grid1.zone1.station1.ns1.tag1.transformfeeder1_220.I_A_rms",
//						"code": "1001",
//	                    "msg": "subscription success"
//	                },
//	                {
//	                    "id": "grid1.zone1.station1.ns1.tag1.transformfeeder1_220.I_B_rms",
//	                    "code": "1002",
//	                    "msg": "subscription failed"
//	                }
//		        ]
//		    }
//		}
//
// @Failure 400 {object} network.FailureResponse{payload=network.RealTimeMonitorPayload} "订阅实时数据结果列表"
//
//	@Example 400 {
//	    "code": 400,
//	    "msg": "failed to get recommend data from redis",
//		"payload": {
//		    "targets": [
//		        {
//					"id": "grid1.zone1.station1.ns1.tag1.transformfeeder1_220.I_A_rms",
//					"code": "1002",
//	                "msg": "subscription failed"
//	            },
//	            {
//	                "id": "grid1.zone1.station1.ns1.tag1.transformfeeder1_220.I_B_rms",
//	                "code": "1002",
//	                "msg": "subscription failed"
//	            }
//		    ]
//		}
//	}
//
// @Router /data/realtime [post]
func RealTimeMonitorHandler(c *gin.Context) {
	var request network.RealTimeSubRequest
	var monitorAction string
	var monitorID string

	if err := c.ShouldBindJSON(&request); err != nil {
		logger.Error(c, "failed to unmarshal real time query request", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  err.Error(),
		})
		return
	}

	if request.Action == constants.MonitorStartAction && request.MonitorID == "" {
		monitorAction = request.Action
		id, err := uuid.NewV4()
		if err != nil {
			logger.Error(c, "failed to generate monitor id", "error", err)
			c.JSON(http.StatusOK, network.FailureResponse{
				Code: http.StatusBadRequest,
				Msg:  err.Error(),
			})
			return
		}
		monitorID = id.String()
	} else if request.Action == constants.MonitorStartAction && request.MonitorID != "" {
		monitorAction = constants.MonitorAppendAction
		monitorID = request.MonitorID
	} else if request.Action == constants.MonitorStopAction && request.MonitorID != "" {
		monitorAction = request.Action
		monitorID = request.MonitorID
	}

	pgClient := database.GetPostgresDBClient()
	// open transaction
	tx := pgClient.Begin()
	defer tx.Commit()

	switch monitorAction {
	case constants.MonitorStartAction:
		results, err := globalMonitorState.CreateConfig(c, tx, monitorID, request.Components)
		if err != nil {
			logger.Error(c, "create real time data monitor config failed", "error", err)
			c.JSON(http.StatusOK, network.FailureResponse{
				Code: http.StatusBadRequest,
				Msg:  err.Error(),
				PayLoad: network.RealTimeSubPayload{
					MonitorID:     monitorID,
					TargetResults: results,
				},
			})
			return
		}

		c.JSON(http.StatusOK, network.SuccessResponse{
			Code: http.StatusOK,
			Msg:  "success",
			PayLoad: network.RealTimeSubPayload{
				MonitorID:     monitorID,
				TargetResults: results,
			},
		})
		return
	case constants.MonitorStopAction:
		results, err := globalMonitorState.RemoveTargets(c, monitorID, request.Components)
		if err != nil {
			logger.Error(c, "remove target to real time data monitor config failed", "error", err)
			c.JSON(http.StatusOK, network.FailureResponse{
				Code: http.StatusBadRequest,
				Msg:  err.Error(),
				PayLoad: network.RealTimeSubPayload{
					MonitorID:     monitorID,
					TargetResults: results,
				},
			})
			return
		}

		c.JSON(http.StatusOK, network.SuccessResponse{
			Code: http.StatusOK,
			Msg:  "success",
			PayLoad: network.RealTimeSubPayload{
				MonitorID:     monitorID,
				TargetResults: results,
			},
		})
		return
	case constants.MonitorAppendAction:
		results, err := globalMonitorState.AppendTargets(c, tx, monitorID, request.Components)
		if err != nil {
			logger.Error(c, "append target to real time data monitor config failed", "error", err)
			c.JSON(http.StatusOK, network.FailureResponse{
				Code: http.StatusBadRequest,
				Msg:  err.Error(),
				PayLoad: network.RealTimeSubPayload{
					MonitorID:     monitorID,
					TargetResults: results,
				},
			})
			return
		}

		c.JSON(http.StatusOK, network.SuccessResponse{
			Code: http.StatusOK,
			Msg:  "success",
			PayLoad: network.RealTimeSubPayload{
				MonitorID:     monitorID,
				TargetResults: results,
			},
		})
		return
	default:
		err := fmt.Errorf("%w: request action is %s", constants.ErrUnsupportedAction, request.Action)
		logger.Error(c, "unsupported action of real time data monitor request", "error", err)
		requestTargetsCount := processRealTimeRequestCount(request.Components)
		results := processRealTimeRequestTargets(request.Components, requestTargetsCount, err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  err.Error(),
			PayLoad: network.RealTimeSubPayload{
				MonitorID:     monitorID,
				TargetResults: results,
			},
		})
		return
	}
}

// RealTimeMonitorComponent define struct of real time monitor component
type RealTimeMonitorComponent struct {
	targets     []string
	targetParam map[string]int
}

// RealTimeMonitorConfig define struct of real time monitor config
type RealTimeMonitorConfig struct {
	noticeChan chan struct{}
	components map[string]*RealTimeMonitorComponent
}

// SharedMonitorState define struct of shared monitor state with mutex
type SharedMonitorState struct {
	monitorMap map[string]*RealTimeMonitorConfig
	mutex      sync.RWMutex
}

// NewSharedMonitorState define function to create new SharedMonitorState
func NewSharedMonitorState() *SharedMonitorState {
	return &SharedMonitorState{
		monitorMap: make(map[string]*RealTimeMonitorConfig),
	}
}

// CreateConfig define function to create config in SharedMonitorState
func (s *SharedMonitorState) CreateConfig(ctx context.Context, tx *gorm.DB, monitorID string, components []network.RealTimeComponentItem) ([]network.TargetResult, error) {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	requestTargetsCount := processRealTimeRequestCount(components)
	targetProcessResults := make([]network.TargetResult, 0, requestTargetsCount)

	if _, exist := s.monitorMap[monitorID]; exist {
		err := fmt.Errorf("monitorID %s already exists. Use AppendTargets to modify existing config", monitorID)
		logger.Error(ctx, "monitorID already exists. Use AppendTargets to modify existing config", "error", err)
		return processRealTimeRequestTargets(components, requestTargetsCount, err), err
	}

	config := &RealTimeMonitorConfig{
		noticeChan: make(chan struct{}),
		components: make(map[string]*RealTimeMonitorComponent),
	}

	for _, componentItem := range components {
		interval := componentItem.Interval
		for _, target := range componentItem.Targets {
			var targetResult network.TargetResult
			targetResult.ID = target

			targetModel, err := database.ParseDataIdentifierToken(ctx, tx, target)
			if err != nil {
				logger.Error(ctx, "parse data indentity token failed", "error", err, "identity_token", target)
				targetResult.Code = constants.SubFailedCode
				targetResult.Msg = fmt.Sprintf("%s: %s", constants.SubFailedMsg, err.Error())
				targetProcessResults = append(targetProcessResults, targetResult)
				continue
			}

			targetResult.Code = constants.SubSuccessCode
			targetResult.Msg = constants.SubSuccessMsg
			targetProcessResults = append(targetProcessResults, targetResult)
			if comp, ok := config.components[interval]; !ok {
				targets := make([]string, 0, len(componentItem.Targets))
				targetParam := make(map[string]int)
				targetParam[target] = targetModel.GetMeasurementInfo().Size
				config.components[interval] = &RealTimeMonitorComponent{
					targets:     append(targets, target),
					targetParam: targetParam,
				}
			} else {
				comp.targets = append(comp.targets, target)
				comp.targetParam[target] = targetModel.GetMeasurementInfo().Size
			}
		}
	}

	s.monitorMap[monitorID] = config
	return targetProcessResults, nil
}

// AppendTargets define function to append targets in SharedMonitorState
func (s *SharedMonitorState) AppendTargets(ctx context.Context, tx *gorm.DB, monitorID string, components []network.RealTimeComponentItem) ([]network.TargetResult, error) {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	requestTargetsCount := processRealTimeRequestCount(components)
	targetProcessResults := make([]network.TargetResult, 0, requestTargetsCount)

	config, exist := s.monitorMap[monitorID]
	if !exist {
		err := fmt.Errorf("monitorID %s not found. Use CreateConfig to start a new config", monitorID)
		logger.Error(ctx, "monitorID not found. Use CreateConfig to start a new config", "error", err)
		return processRealTimeRequestTargets(components, requestTargetsCount, err), err
	}

	for _, componentItem := range components {
		interval := componentItem.Interval
		for _, target := range componentItem.Targets {
			var targetResult network.TargetResult
			targetResult.ID = target

			targetModel, err := database.ParseDataIdentifierToken(ctx, tx, target)
			if err != nil {
				logger.Error(ctx, "parse data indentity token failed", "error", err, "identity_token", target)
				targetResult.Code = constants.SubFailedCode
				targetResult.Msg = fmt.Sprintf("%s: %s", constants.SubFailedMsg, err.Error())
				targetProcessResults = append(targetProcessResults, targetResult)
				continue
			}

			targetResult.Code = constants.SubSuccessCode
			targetResult.Msg = constants.SubSuccessMsg
			targetProcessResults = append(targetProcessResults, targetResult)
			if comp, ok := config.components[interval]; !ok {
				targets := make([]string, 0, len(componentItem.Targets))
				targetParam := make(map[string]int)
				targetParam[target] = targetModel.GetMeasurementInfo().Size
				config.components[interval] = &RealTimeMonitorComponent{
					targets: append(targets, target),
				}
			} else {
				comp.targets = append(comp.targets, target)
				comp.targetParam[target] = targetModel.GetMeasurementInfo().Size
			}
		}
	}
	config.noticeChan <- struct{}{}
	return targetProcessResults, nil
}

// UpsertTargets define function to upsert targets in SharedMonitorState
func (s *SharedMonitorState) UpsertTargets(ctx context.Context, tx *gorm.DB, monitorID string, components []network.RealTimeComponentItem) ([]network.TargetResult, error) {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	config, exist := s.monitorMap[monitorID]
	if !exist {
		// create new config
		config = &RealTimeMonitorConfig{
			noticeChan: make(chan struct{}),
			components: make(map[string]*RealTimeMonitorComponent),
		}

		targetProcessResults := make([]network.TargetResult, 0, processRealTimeRequestCount(components))
		for _, componentItem := range components {
			interval := componentItem.Interval
			for _, target := range componentItem.Targets {
				var targetResult network.TargetResult
				targetResult.ID = target

				targetModel, err := database.ParseDataIdentifierToken(ctx, tx, target)
				if err != nil {
					logger.Error(ctx, "parse data indentity token failed", "error", err, "identity_token", target)
					targetResult.Code = constants.SubFailedCode
					targetResult.Msg = fmt.Sprintf("%s: %s", constants.SubFailedMsg, err.Error())
					targetProcessResults = append(targetProcessResults, targetResult)
					continue
				}

				targetResult.Code = constants.SubSuccessCode
				targetResult.Msg = constants.SubSuccessMsg
				if comp, ok := config.components[interval]; !ok {
					targets := make([]string, 0, len(componentItem.Targets))
					targetParam := make(map[string]int)
					targetParam[target] = targetModel.GetMeasurementInfo().Size
					config.components[interval] = &RealTimeMonitorComponent{
						targets: append(targets, target),
					}
				} else {
					comp.targets = append(comp.targets, target)
					comp.targetParam[target] = targetModel.GetMeasurementInfo().Size
				}
			}
		}
		s.monitorMap[monitorID] = config
		return targetProcessResults, nil
	}

	targetProcessResults := make([]network.TargetResult, 0, processRealTimeRequestCount(components))
	for _, componentItem := range components {
		interval := componentItem.Interval
		for _, target := range componentItem.Targets {
			var targetResult network.TargetResult
			targetResult.ID = target

			targetModel, err := database.ParseDataIdentifierToken(ctx, tx, target)
			if err != nil {
				logger.Error(ctx, "parse data indentity token failed", "error", err, "identity_token", target)
				targetResult.Code = constants.SubFailedCode
				targetResult.Msg = fmt.Sprintf("%s: %s", constants.SubFailedMsg, err.Error())
				targetProcessResults = append(targetProcessResults, targetResult)
				continue
			}

			targetResult.Code = constants.SubSuccessCode
			targetResult.Msg = constants.SubSuccessMsg
			targetProcessResults = append(targetProcessResults, targetResult)
			if comp, ok := config.components[interval]; !ok {
				targets := make([]string, 0, len(componentItem.Targets))
				targetParam := make(map[string]int)
				targetParam[target] = targetModel.GetMeasurementInfo().Size
				config.components[interval] = &RealTimeMonitorComponent{
					targets: append(targets, target),
				}
			} else {
				comp.targets = append(comp.targets, target)
				comp.targetParam[target] = targetModel.GetMeasurementInfo().Size
			}
		}
	}
	config.noticeChan <- struct{}{}
	return targetProcessResults, nil
}

// Get define function to get value from SharedMonitorState
func (s *SharedMonitorState) Get(monitorID, interval string) ([]string, bool) {
	s.mutex.RLock()
	defer s.mutex.RUnlock()

	config, ok := s.monitorMap[monitorID]
	if !ok {
		return nil, false
	}

	component, ok := config.components[interval]
	if !ok {
		return nil, false
	}
	return component.targets, true
}

// RemoveTargets define function to remove targets in SharedMonitorState
func (s *SharedMonitorState) RemoveTargets(ctx context.Context, monitorID string, components []network.RealTimeComponentItem) ([]network.TargetResult, error) {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	requestTargetsCount := processRealTimeRequestCount(components)
	targetProcessResults := make([]network.TargetResult, 0, requestTargetsCount)

	config, exist := s.monitorMap[monitorID]
	if !exist {
		err := fmt.Errorf("monitorID %s not found", monitorID)
		logger.Error(ctx, "monitorID not found in remove targets operation", "error", err)
		return processRealTimeRequestTargets(components, requestTargetsCount, err), err
	}

	// components is the list of items to be removed passed in the request
	for _, compent := range components {
		interval := compent.Interval
		// comp is the locally running listener configuration
		comp, compExist := config.components[interval]
		if !compExist {
			logger.Error(ctx, fmt.Sprintf("component with interval %s not found under monitorID %s", interval, monitorID), "monitorID", monitorID, "interval", interval)
			for _, target := range comp.targets {
				targetResult := network.TargetResult{
					ID:   target,
					Code: constants.CancelSubFailedCode,
					Msg:  constants.CancelSubFailedMsg,
				}
				targetProcessResults = append(targetProcessResults, targetResult)
			}
			continue
		}

		targetsToRemoveMap := make(map[string]struct{})
		for _, target := range compent.Targets {
			targetsToRemoveMap[target] = struct{}{}
		}

		var newTargets []string
		for _, existingTarget := range comp.targets {
			if _, found := targetsToRemoveMap[existingTarget]; !found {
				newTargets = append(newTargets, existingTarget)
			} else {
				targetResult := network.TargetResult{
					ID:   existingTarget,
					Code: constants.CancelSubSuccessCode,
					Msg:  constants.CancelSubSuccessMsg,
				}
				targetProcessResults = append(targetProcessResults, targetResult)
				delete(targetsToRemoveMap, existingTarget)
				delete(comp.targetParam, existingTarget)
			}
		}
		comp.targets = newTargets

		if len(comp.targets) == 0 {
			delete(config.components, interval)
		}

		if len(config.components) == 0 {
			delete(s.monitorMap, monitorID)
		}

		if len(targetsToRemoveMap) > 0 {
			err := fmt.Errorf("target remove were not found under monitorID %s and interval %s", monitorID, interval)
			for target := range targetsToRemoveMap {
				targetResult := network.TargetResult{
					ID:   target,
					Code: constants.CancelSubFailedCode,
					Msg:  fmt.Sprintf("%s: %s", constants.SubFailedMsg, err.Error()),
				}
				targetProcessResults = append(targetProcessResults, targetResult)
			}
		}
	}

	config.noticeChan <- struct{}{}
	return targetProcessResults, nil
}

func processRealTimeRequestCount(components []network.RealTimeComponentItem) int {
	totalTargetsCount := 0
	for _, compItem := range components {
		totalTargetsCount += len(compItem.Targets)
	}
	return totalTargetsCount
}

func processRealTimeRequestTargets(components []network.RealTimeComponentItem, targetCount int, err error) []network.TargetResult {
	targetProcessResults := make([]network.TargetResult, 0, targetCount)
	for _, componentItem := range components {
		for _, target := range componentItem.Targets {
			var targetResult network.TargetResult
			targetResult.ID = target
			targetResult.Code = constants.SubFailedCode
			targetResult.Msg = fmt.Sprintf("%s: %s", constants.SubFailedMsg, err.Error())
			targetProcessResults = append(targetProcessResults, targetResult)
		}
	}
	return targetProcessResults
}