package services

import (
	"encoding/json"
	"strings"
	"testing"

	"agent-desk/internal/ai/workflow/dsl"
	workflowregistry "agent-desk/internal/ai/workflow/registry"
	workflowvalidator "agent-desk/internal/ai/workflow/validator"
	"agent-desk/internal/models"
	"agent-desk/internal/pkg/dto"
	"agent-desk/internal/pkg/dto/request"
	"agent-desk/internal/pkg/enums"

	"github.com/glebarez/sqlite"
	"github.com/mlogclub/simple/sqls"
	"gorm.io/gorm"
)

func TestAIAgentServiceCreatesDefaultWorkflow(t *testing.T) {
	setupAIAgentWorkflowTestDB(t)
	operator := aiAgentWorkflowTestOperator()
	aiConfigID := createAIAgentWorkflowTestConfig(t)
	knowledgeID := createAIAgentWorkflowTestKnowledgeBase(t)

	item, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
		Name:         "workflow agent",
		AIConfigID:   aiConfigID,
		ServiceMode:  enums.IMConversationServiceModeAIOnly,
		HandoffMode:  enums.AIAgentHandoffModeWaitPool,
		FallbackMode: enums.AIAgentFallbackModeNoAnswer,
		KnowledgeIDs: []int64{knowledgeID},
	}, operator)
	if err != nil {
		t.Fatalf("CreateAIAgent() error = %v", err)
	}

	workflow, err := AIWorkflowService.GetOrCreateAgentWorkflow(item.ID, operator)
	if err != nil {
		t.Fatalf("GetOrCreateAgentWorkflow() error = %v", err)
	}
	if workflow.AgentID != item.ID {
		t.Fatalf("expected workflow agent id %d, got %d", item.ID, workflow.AgentID)
	}
	if workflow.Name != item.Name+" 会话流程" {
		t.Fatalf("unexpected workflow name: %s", workflow.Name)
	}
	var stored dsl.Definition
	if err := json.Unmarshal([]byte(workflow.DraftDefinition), &stored); err != nil {
		t.Fatalf("unmarshal draft definition: %v", err)
	}
	if stored.SchemaVersion != dsl.SchemaVersion || nodeTypeByID(stored, "start_1") != workflowregistry.NodeTypeStart {
		t.Fatalf("expected default draft definition")
	}
	validation := workflowvalidator.ValidateDefinition(stored, workflowregistry.DefaultRegistry())
	if !validation.Valid {
		t.Fatalf("expected default workflow to be valid, got %#v", validation.Errors)
	}
	if nodeTypeByID(stored, "understanding_1") != workflowregistry.NodeTypeConversationUnderstanding {
		t.Fatalf("expected default workflow to include conversation understanding, got nodes: %#v", stored.Nodes)
	}
	if nodeTypeByID(stored, "policy_1") != workflowregistry.NodeTypeReplyPolicy {
		t.Fatalf("expected default workflow to include reply policy, got nodes: %#v", stored.Nodes)
	}
	if !workflowEdgeExists(stored, "start_1", "understanding_1") || !workflowEdgeExists(stored, "understanding_1", "policy_1") {
		t.Fatalf("expected default workflow to start with policy-first understanding flow, got edges: %#v", stored.Edges)
	}
	for _, nodeType := range []string{
		workflowregistry.NodeTypeConversationUnderstanding,
		workflowregistry.NodeTypeReplyPolicy,
		workflowregistry.NodeTypeHandoffToHuman,
		workflowregistry.NodeTypePrepareTicketDraft,
		workflowregistry.NodeTypeHumanConfirm,
		workflowregistry.NodeTypeCreateTicket,
		workflowregistry.NodeTypeKnowledgeRetrieve,
		workflowregistry.NodeTypeAnswerabilityGate,
		workflowregistry.NodeTypeLLMReply,
		workflowregistry.NodeTypeSendReply,
	} {
		if !workflowHasNodeType(stored, nodeType) {
			t.Fatalf("expected default workflow to include %s node: %#v", nodeType, stored.Nodes)
		}
	}
	assertConditionBranchToNodeType(t, stored, "policy_route_1", workflowregistry.NodeTypeSendReply, "eq", "direct_reply")
	assertConditionBranchToNodeType(t, stored, "policy_route_1", workflowregistry.NodeTypeHandoffToHuman, "eq", "handoff_to_human")
	assertConditionBranchToNodeType(t, stored, "policy_route_1", workflowregistry.NodeTypePrepareTicketDraft, "eq", "prepare_ticket")
	assertConditionBranchToNodeID(t, stored, "ticket_draft_route_1", "ticket_confirm_prompt_1", "is_true", nil)
	assertDefaultBranchToNodeID(t, stored, "ticket_draft_route_1", "ticket_followup_reply_1")
	assertConditionBranchToNodeID(t, stored, "answerability_route_1", "reply_1", "eq", "answerable")
	assertDefaultBranchToNodeID(t, stored, "answerability_route_1", "fallback_reply_1")
	if !workflowEdgeExists(stored, "create_ticket_1", "ticket_result_reply_1") {
		t.Fatalf("expected create_ticket to flow into a customer-visible result reply")
	}
	assertConditionBranchesHavePortEdges(t, stored, "policy_route_1")
	assertConditionBranchesHavePortEdges(t, stored, "ticket_draft_route_1")
	assertConditionBranchesHavePortEdges(t, stored, "ticket_confirm_route_1")
	assertConditionBranchesHavePortEdges(t, stored, "answerability_route_1")
	assertConditionBranchOrder(t, stored, "policy_route_1", []string{
		"handoff",
		"direct",
		"clarify",
		"end_conversation",
		"ticket",
		"knowledge",
		"default",
	})
	assertConditionPortEdgeOrder(t, stored, "policy_route_1", []string{
		"handoff",
		"direct",
		"clarify",
		"end_conversation",
		"ticket",
		"knowledge",
		"default",
	})
}

func TestAIWorkflowServiceDefaultAgentWorkflowDefinitionIsValid(t *testing.T) {
	definition := AIWorkflowService.DefaultAgentWorkflowDefinition()
	if definition.SchemaVersion != dsl.SchemaVersion || nodeTypeByID(definition, "start_1") != workflowregistry.NodeTypeStart {
		t.Fatalf("expected default workflow definition")
	}
	validation := workflowvalidator.ValidateDefinition(definition, workflowregistry.DefaultRegistry())
	if !validation.Valid {
		t.Fatalf("expected default workflow definition to be valid, got %#v", validation.Errors)
	}
	if nodeTypeByID(definition, "understanding_1") != workflowregistry.NodeTypeConversationUnderstanding {
		t.Fatalf("expected default workflow to include conversation understanding, got nodes: %#v", definition.Nodes)
	}
	if nodeTypeByID(definition, "policy_1") != workflowregistry.NodeTypeReplyPolicy {
		t.Fatalf("expected default workflow to include reply policy, got nodes: %#v", definition.Nodes)
	}
	if !workflowHasNodeType(definition, workflowregistry.NodeTypeHandoffToHuman) {
		t.Fatalf("expected default workflow to include human handoff node")
	}
	if !workflowHasNodeType(definition, workflowregistry.NodeTypeCreateTicket) {
		t.Fatalf("expected default workflow to include ticket creation node")
	}
}

func TestAIWorkflowServiceDefaultAgentWorkflowTicketPromptIncludesDraftFields(t *testing.T) {
	definition := AIWorkflowService.DefaultAgentWorkflowDefinition()
	prompt := workflowNodeByID(t, definition, "ticket_confirm_prompt_1")
	if _, ok := prompt.Data.InputsValues["ticketTitle"]; !ok {
		t.Fatalf("expected ticket confirm prompt to map ticketTitle")
	}
	if _, ok := prompt.Data.InputsValues["ticketDescription"]; !ok {
		t.Fatalf("expected ticket confirm prompt to map ticketDescription")
	}
	config := map[string]any{}
	if err := json.Unmarshal(prompt.Data.Config, &config); err != nil {
		t.Fatalf("unmarshal prompt config: %v", err)
	}
	staticReply, _ := config["staticReply"].(string)
	if !strings.Contains(staticReply, "{{ticketTitle}}") || !strings.Contains(staticReply, "{{ticketDescription}}") {
		t.Fatalf("expected prompt template to include ticket title and description, got %q", staticReply)
	}
}

func TestAIWorkflowServiceDefaultAgentWorkflowLayoutDoesNotOverlap(t *testing.T) {
	definition := AIWorkflowService.DefaultAgentWorkflowDefinition()
	assertWorkflowLayoutDoesNotOverlap(t, definition)
}

func TestAIWorkflowServicePublishAgentWorkflowBindsAgentVersion(t *testing.T) {
	setupAIAgentWorkflowTestDB(t)
	operator := aiAgentWorkflowTestOperator()
	aiConfigID := createAIAgentWorkflowTestConfig(t)
	knowledgeID := createAIAgentWorkflowTestKnowledgeBase(t)

	agent, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
		Name:         "workflow agent without version",
		AIConfigID:   aiConfigID,
		ServiceMode:  enums.IMConversationServiceModeAIOnly,
		HandoffMode:  enums.AIAgentHandoffModeWaitPool,
		FallbackMode: enums.AIAgentFallbackModeNoAnswer,
		KnowledgeIDs: []int64{knowledgeID},
	}, operator)
	if err != nil {
		t.Fatalf("CreateAIAgent() error = %v", err)
	}
	workflow, err := AIWorkflowService.SaveAgentWorkflow(request.SaveAIWorkflowRequest{
		AgentID:     agent.ID,
		Name:        "After sales flow",
		Description: "Support workflow",
		Definition:  validAIWorkflowDefinition(),
	}, operator)
	if err != nil {
		t.Fatalf("SaveAgentWorkflow() error = %v", err)
	}

	version, err := AIWorkflowService.PublishAgentWorkflow(request.PublishAIWorkflowRequest{
		AgentID:    agent.ID,
		Definition: validAIWorkflowDefinition(),
	}, operator)
	if err != nil {
		t.Fatalf("PublishAgentWorkflow() error = %v", err)
	}
	if version.WorkflowID != workflow.ID {
		t.Fatalf("expected version workflow id %d, got %d", workflow.ID, version.WorkflowID)
	}
	storedAgent := AIAgentService.Get(agent.ID)
	if storedAgent == nil {
		t.Fatalf("expected stored agent")
	}
	if storedAgent.WorkflowVersionID != version.ID {
		t.Fatalf("expected agent workflow version %d, got %d", version.ID, storedAgent.WorkflowVersionID)
	}
}

func setupAIAgentWorkflowTestDB(t *testing.T) {
	t.Helper()
	db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
	if err != nil {
		t.Fatalf("open sqlite db: %v", err)
	}
	if err := db.AutoMigrate(&models.AIAgent{}, &models.AIConfig{}, &models.KnowledgeBase{}, &models.AIWorkflow{}, &models.AIWorkflowVersion{}); err != nil {
		t.Fatalf("auto migrate: %v", err)
	}
	sqls.SetDB(db)
}

func createAIAgentWorkflowTestConfig(t *testing.T) int64 {
	t.Helper()
	item := &models.AIConfig{
		Name:      "workflow-test-config",
		Provider:  enums.AIProviderOpenAI,
		ModelType: enums.AIModelTypeLLM,
		ModelName: "gpt-test",
		Status:    enums.StatusOk,
	}
	if err := sqls.DB().Create(item).Error; err != nil {
		t.Fatalf("create ai config: %v", err)
	}
	return item.ID
}

func createAIAgentWorkflowTestKnowledgeBase(t *testing.T) int64 {
	t.Helper()
	item := &models.KnowledgeBase{
		Name:          "workflow-test-kb",
		KnowledgeType: string(enums.KnowledgeBaseTypeFAQ),
		Status:        enums.StatusOk,
	}
	if err := sqls.DB().Create(item).Error; err != nil {
		t.Fatalf("create knowledge base: %v", err)
	}
	return item.ID
}

func createAIAgentWorkflowVersion(t *testing.T) int64 {
	t.Helper()
	workflow := &models.AIWorkflow{
		Name:    "workflow-test",
		AgentID: 1,
		Status:  enums.StatusOk,
	}
	if err := sqls.DB().Create(workflow).Error; err != nil {
		t.Fatalf("create workflow: %v", err)
	}
	version := &models.AIWorkflowVersion{
		WorkflowID: workflow.ID,
		Version:    1,
		Status:     enums.StatusOk,
	}
	if err := sqls.DB().Create(version).Error; err != nil {
		t.Fatalf("create workflow version: %v", err)
	}
	return version.ID
}

func aiAgentWorkflowTestOperator() *dto.AuthPrincipal {
	return &dto.AuthPrincipal{
		UserID:   1,
		Username: "agent-workflow-tester",
		Nickname: "agent-workflow-tester",
	}
}

func workflowHasNodeType(def dsl.Definition, nodeType string) bool {
	for _, node := range def.Nodes {
		if node.Type == nodeType {
			return true
		}
	}
	return false
}

func nodeTypeByID(def dsl.Definition, nodeID string) string {
	for _, node := range def.Nodes {
		if node.ID == nodeID {
			return node.Type
		}
	}
	return ""
}

func workflowNodeByID(t *testing.T, def dsl.Definition, nodeID string) dsl.Node {
	t.Helper()
	for _, node := range def.Nodes {
		if node.ID == nodeID {
			return node
		}
	}
	t.Fatalf("workflow node not found: %s", nodeID)
	return dsl.Node{}
}

func assertConditionBranchToNodeType(t *testing.T, def dsl.Definition, sourceID string, targetType string, operator string, right any) {
	t.Helper()
	nodeTypes := workflowNodeTypeMap(def)
	for _, branch := range conditionBranches(t, def, sourceID) {
		if nodeTypes[branch.TargetNodeID] != targetType || branch.Condition == nil {
			continue
		}
		if branch.Condition.Operator == operator && branch.Condition.Right == right {
			return
		}
	}
	t.Fatalf("expected %s condition branch from %s to %s with right=%v", operator, sourceID, targetType, right)
}

func assertConditionBranchToNodeID(t *testing.T, def dsl.Definition, sourceID string, targetID string, operator string, right any) {
	t.Helper()
	for _, branch := range conditionBranches(t, def, sourceID) {
		if branch.TargetNodeID != targetID || branch.Condition == nil {
			continue
		}
		if branch.Condition.Operator == operator && branch.Condition.Right == right {
			return
		}
	}
	t.Fatalf("expected %s condition branch from %s to %s with right=%v", operator, sourceID, targetID, right)
}

func assertDefaultBranchToNodeID(t *testing.T, def dsl.Definition, sourceID string, targetID string) {
	t.Helper()
	for _, branch := range conditionBranches(t, def, sourceID) {
		if branch.TargetNodeID == targetID && branch.Default {
			return
		}
	}
	t.Fatalf("expected default branch from %s to %s", sourceID, targetID)
}

func conditionBranches(t *testing.T, def dsl.Definition, nodeID string) []dsl.ConditionBranch {
	t.Helper()
	for _, node := range def.Nodes {
		if node.ID != nodeID {
			continue
		}
		var config dsl.ConditionConfig
		if err := json.Unmarshal(node.Data.Config, &config); err != nil {
			t.Fatalf("unmarshal condition config for %s: %v", nodeID, err)
		}
		return config.Branches
	}
	t.Fatalf("condition node not found: %s", nodeID)
	return nil
}

func assertConditionBranchesHavePortEdges(t *testing.T, def dsl.Definition, nodeID string) {
	t.Helper()
	for _, branch := range conditionBranches(t, def, nodeID) {
		if !workflowPortEdgeExists(def, nodeID, branch.TargetNodeID, branch.ID) {
			t.Fatalf("expected condition branch %s.%s to have port edge to %s", nodeID, branch.ID, branch.TargetNodeID)
		}
	}
}

func assertConditionBranchOrder(t *testing.T, def dsl.Definition, nodeID string, want []string) {
	t.Helper()
	branches := conditionBranches(t, def, nodeID)
	if len(branches) != len(want) {
		t.Fatalf("expected %s branch order %v, got %#v", nodeID, want, branches)
	}
	for index, branch := range branches {
		if branch.ID != want[index] {
			t.Fatalf("expected %s branch order %v, got branch %d = %s", nodeID, want, index, branch.ID)
		}
	}
}

func assertConditionPortEdgeOrder(t *testing.T, def dsl.Definition, nodeID string, want []string) {
	t.Helper()
	got := make([]string, 0, len(want))
	for _, edge := range def.Edges {
		if edge.SourceNodeID == nodeID {
			got = append(got, edge.SourcePortID)
		}
	}
	if len(got) != len(want) {
		t.Fatalf("expected %s port edge order %v, got %v", nodeID, want, got)
	}
	for index, sourcePortID := range got {
		if sourcePortID != want[index] {
			t.Fatalf("expected %s port edge order %v, got edge %d = %s", nodeID, want, index, sourcePortID)
		}
	}
}

func workflowPortEdgeExists(def dsl.Definition, sourceID string, targetID string, sourcePortID string) bool {
	for _, edge := range def.Edges {
		if edge.SourceNodeID == sourceID && edge.TargetNodeID == targetID && edge.SourcePortID == sourcePortID {
			return true
		}
	}
	return false
}

func workflowEdgeExists(def dsl.Definition, sourceID string, targetID string) bool {
	for _, edge := range def.Edges {
		if edge.SourceNodeID == sourceID && edge.TargetNodeID == targetID {
			return true
		}
	}
	return false
}

type workflowLayoutBox struct {
	NodeID string
	Left   float64
	Top    float64
	Right  float64
	Bottom float64
}

func assertWorkflowLayoutDoesNotOverlap(t *testing.T, def dsl.Definition) {
	t.Helper()
	boxes := make([]workflowLayoutBox, 0, len(def.Nodes))
	for _, node := range def.Nodes {
		width, height := defaultWorkflowNodeRenderSize(node.Type)
		boxes = append(boxes, workflowLayoutBox{
			NodeID: node.ID,
			Left:   node.Meta.Position.X,
			Top:    node.Meta.Position.Y,
			Right:  node.Meta.Position.X + width,
			Bottom: node.Meta.Position.Y + height,
		})
	}
	const minGap = 32.0
	for i := range boxes {
		for j := i + 1; j < len(boxes); j++ {
			if workflowBoxesOverlapWithGap(boxes[i], boxes[j], minGap) {
				t.Fatalf("default workflow nodes are too close or overlapping: %s=%+v %s=%+v", boxes[i].NodeID, boxes[i], boxes[j].NodeID, boxes[j])
			}
		}
	}
}

func defaultWorkflowNodeRenderSize(nodeType string) (float64, float64) {
	if nodeType == workflowregistry.NodeTypeCondition {
		return 160, 160
	}
	return 220, 128
}

func workflowBoxesOverlapWithGap(a workflowLayoutBox, b workflowLayoutBox, gap float64) bool {
	return a.Left < b.Right+gap && a.Right+gap > b.Left && a.Top < b.Bottom+gap && a.Bottom+gap > b.Top
}

func workflowNodeTypeMap(def dsl.Definition) map[string]string {
	ret := make(map[string]string, len(def.Nodes))
	for _, node := range def.Nodes {
		ret[node.ID] = node.Type
	}
	return ret
}