package main

import (
	"encoding/json"
	"testing"

	"git.iwork-ai.com/xdc/iqudo-top1/internal/model"
	"git.iwork-ai.com/xdc/iqudo-top1/internal/sop"
	"gorm.io/datatypes"
)

func TestPetDoctorSOPPassesPublishValidation(t *testing.T) {
	fields := petFieldModels()
	nodes := petNodeModels(petNodes())
	edges := petEdgeModels(petEdges())
	if len(fields) != 11 || len(nodes) != 6 || len(edges) != 5 {
		t.Fatalf("unexpected definition size: fields=%d nodes=%d edges=%d", len(fields), len(nodes), len(edges))
	}
	problems := sop.ValidateForPublish("start", nodes, edges, sop.ValidationContext{
		Fields:    fields,
		StageKeys: []string{"opening", "symptom", "diagnosis", "recommend"},
	})
	if len(problems) > 0 {
		t.Fatalf("pet doctor SOP should be publishable, got: %v", problems)
	}
}

func TestPetDoctorSOPIsSixStepLinearFlow(t *testing.T) {
	wantNodes := []string{"start", "opening", "symptom", "diagnosis", "recommend", "finish"}
	for index, node := range petNodes() {
		if node.Key != wantNodes[index] {
			t.Fatalf("node %d = %s, want %s", index, node.Key, wantNodes[index])
		}
	}
	wantEdges := [][2]string{{"start", "opening"}, {"opening", "symptom"}, {"symptom", "diagnosis"}, {"diagnosis", "recommend"}, {"recommend", "finish"}}
	for index, edge := range petEdges() {
		if edge.Source != wantEdges[index][0] || edge.Target != wantEdges[index][1] {
			t.Fatalf("edge %d = %s -> %s", index, edge.Source, edge.Target)
		}
	}
}

func petFieldModels() []model.ScenarioField {
	definitions := petFieldDefinitions()
	fields := make([]model.ScenarioField, 0, len(definitions))
	for _, definition := range definitions {
		options, _ := json.Marshal(definition.Options)
		validation, _ := json.Marshal(definition.Validation)
		fields = append(fields, model.ScenarioField{
			FieldKey:   definition.Key,
			FieldName:  definition.Name,
			SourcePath: definition.SourcePath,
			FieldType:  definition.Type,
			Required:   definition.Required,
			Options:    datatypes.JSON(options),
			Validation: datatypes.JSON(validation),
		})
	}
	return fields
}

func petNodeModels(definitions []nodeDefinition) []model.SOPNode {
	nodes := make([]model.SOPNode, 0, len(definitions))
	for _, definition := range definitions {
		config, _ := json.Marshal(definition.Config)
		nodes = append(nodes, model.SOPNode{
			NodeKey: definition.Key,
			Type:    definition.Type,
			Title:   definition.Title,
			Content: definition.Content,
			Config:  datatypes.JSON(config),
		})
	}
	return nodes
}

func petEdgeModels(definitions []edgeDefinition) []model.SOPEdge {
	edges := make([]model.SOPEdge, 0, len(definitions))
	for _, definition := range definitions {
		condition, _ := json.Marshal(definition.Condition)
		edges = append(edges, model.SOPEdge{
			SourceNodeKey: definition.Source,
			TargetNodeKey: definition.Target,
			Condition:     datatypes.JSON(condition),
			Priority:      definition.Priority,
		})
	}
	return edges
}