// SPDX-License-Identifier: EUPL-1.2

package agentic

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"strconv"
	"sync/atomic"
	"time"

	core "dappco.re/go/core"
	"github.com/modelcontextprotocol/go-sdk/mcp"
)

// plan := &Plan{ID: "id-1-a3f2b1", Title: "Migrate Core", Status: "draft", Objective: "Replace raw process calls with Core.Process()"}
// r := writePlanResult(PlansRoot(), plan)
type Plan struct {
	ID                string              `json:"id"`
	WorkspaceID       int                 `json:"workspace_id,omitempty"`
	Slug              string              `json:"slug,omitempty"`
	Title             string              `json:"title"`
	Status            string              `json:"status"`
	Repo              string              `json:"repo,omitempty"`
	Org               string              `json:"org,omitempty"`
	Objective         string              `json:"objective"`
	Description       string              `json:"description,omitempty"`
	AgentType         string              `json:"agent_type,omitempty"`
	Context           map[string]any      `json:"context,omitempty"`
	TemplateVersionID int                 `json:"template_version_id,omitempty"`
	TemplateVersion   PlanTemplateVersion `json:"template_version,omitempty"`
	Phases            []Phase             `json:"phases,omitempty"`
	Notes             string              `json:"notes,omitempty"`
	Agent             string              `json:"agent,omitempty"`
	CreatedAt         time.Time           `json:"created_at"`
	UpdatedAt         time.Time           `json:"updated_at"`
	ArchivedAt        time.Time           `json:"archived_at,omitempty"`
}

// plan := agentic.AgentPlan{Slug: "ax-follow-up", Title: "AX follow-up"}
type AgentPlan = Plan

// phase := agentic.Phase{Number: 1, Name: "Migrate strings", Status: "in_progress"}
type Phase struct {
	AgentPlanID        int               `json:"agent_plan_id,omitempty"`
	Number             int               `json:"number"`
	Name               string            `json:"name"`
	Description        string            `json:"description,omitempty"`
	Status             string            `json:"status"`
	Criteria           []string          `json:"criteria,omitempty"`
	CompletionCriteria []string          `json:"completion_criteria,omitempty"`
	Dependencies       []string          `json:"dependencies,omitempty"`
	Tasks              []PlanTask        `json:"tasks,omitempty"`
	Checkpoints        []PhaseCheckpoint `json:"checkpoints,omitempty"`
	Tests              int               `json:"tests,omitempty"`
	Notes              string            `json:"notes,omitempty"`
}

// task := agentic.PlanTask{ID: "1", Title: "Review imports", Status: "pending", File: "pkg/agentic/plan.go", Line: 46}
type PlanTask struct {
	ID          string `json:"id,omitempty"`
	Title       string `json:"title"`
	Description string `json:"description,omitempty"`
	Priority    string `json:"priority,omitempty"`
	Category    string `json:"category,omitempty"`
	Status      string `json:"status,omitempty"`
	Notes       string `json:"notes,omitempty"`
	File        string `json:"file,omitempty"`
	Line        int    `json:"line,omitempty"`
	FileRef     string `json:"file_ref,omitempty"`
	LineRef     int    `json:"line_ref,omitempty"`
}

// task := agentic.Task{ID: "1", Title: "Review imports"}
type Task = PlanTask

// checkpoint := agentic.PhaseCheckpoint{Note: "Build passes", CreatedAt: "2026-03-31T00:00:00Z"}
type PhaseCheckpoint struct {
	Note      string         `json:"note"`
	Context   map[string]any `json:"context,omitempty"`
	CreatedAt string         `json:"created_at,omitempty"`
}

type PlanCreateInput struct {
	Title           string              `json:"title"`
	Slug            string              `json:"slug,omitempty"`
	Objective       string              `json:"objective,omitempty"`
	Description     string              `json:"description,omitempty"`
	Context         map[string]any      `json:"context,omitempty"`
	AgentType       string              `json:"agent_type,omitempty"`
	TemplateVersion PlanTemplateVersion `json:"template_version,omitempty"`
	Repo            string              `json:"repo,omitempty"`
	Org             string              `json:"org,omitempty"`
	Phases          []Phase             `json:"phases,omitempty"`
	Notes           string              `json:"notes,omitempty"`
}

type PlanCreateOutput struct {
	Success bool   `json:"success"`
	ID      string `json:"id"`
	Path    string `json:"path"`
}

type PlanReadInput struct {
	ID   string `json:"id,omitempty"`
	Slug string `json:"slug,omitempty"`
}

type PlanReadOutput struct {
	Success bool `json:"success"`
	Plan    Plan `json:"plan"`
}

type PlanUpdateInput struct {
	ID          string         `json:"id,omitempty"`
	Slug        string         `json:"slug,omitempty"`
	Status      string         `json:"status,omitempty"`
	Title       string         `json:"title,omitempty"`
	Objective   string         `json:"objective,omitempty"`
	Description string         `json:"description,omitempty"`
	Context     map[string]any `json:"context,omitempty"`
	Phases      []Phase        `json:"phases,omitempty"`
	Notes       string         `json:"notes,omitempty"`
	Agent       string         `json:"agent,omitempty"`
	AgentType   string         `json:"agent_type,omitempty"`
}

type PlanUpdateOutput struct {
	Success bool `json:"success"`
	Plan    Plan `json:"plan"`
}

type PlanDeleteInput struct {
	ID     string `json:"id,omitempty"`
	Slug   string `json:"slug,omitempty"`
	Reason string `json:"reason,omitempty"`
}

type PlanDeleteOutput struct {
	Success bool   `json:"success"`
	Deleted string `json:"deleted"`
}

type PlanListInput struct {
	Status string `json:"status,omitempty"`
	Repo   string `json:"repo,omitempty"`
	Limit  int    `json:"limit,omitempty"`
}

type PlanListOutput struct {
	Success bool   `json:"success"`
	Count   int    `json:"count"`
	Plans   []Plan `json:"plans"`
}

const planListDefaultLimit = 20

var planIDCounter atomic.Uint64

// result := c.Action("plan.create").Run(ctx, core.NewOptions(
//
//	core.Option{Key: "title", Value: "AX RFC follow-up"},
//	core.Option{Key: "objective", Value: "Register plan actions"},
//
// ))
func (s *PrepSubsystem) handlePlanCreate(ctx context.Context, options core.Options) core.Result {
	_, output, err := s.planCreate(ctx, nil, PlanCreateInput{
		Title:       optionStringValue(options, "title"),
		Slug:        optionStringValue(options, "slug"),
		Objective:   optionStringValue(options, "objective"),
		Description: optionStringValue(options, "description"),
		Context:     optionAnyMapValue(options, "context"),
		AgentType:   optionStringValue(options, "agent_type", "agent"),
		Repo:        optionStringValue(options, "repo"),
		Org:         optionStringValue(options, "org"),
		Phases:      planPhasesValue(options, "phases"),
		Notes:       optionStringValue(options, "notes"),
	})
	if err != nil {
		return core.Result{Value: err, OK: false}
	}
	return core.Result{Value: output, OK: true}
}

// result := c.Action("plan.read").Run(ctx, core.NewOptions(core.Option{Key: "id", Value: "id-42-a3f2b1"}))
func (s *PrepSubsystem) handlePlanRead(ctx context.Context, options core.Options) core.Result {
	_, output, err := s.planRead(ctx, nil, PlanReadInput{
		ID:   optionStringValue(options, "id", "_arg"),
		Slug: optionStringValue(options, "slug"),
	})
	if err != nil {
		return core.Result{Value: err, OK: false}
	}
	return core.Result{Value: output, OK: true}
}

// result := c.Action("plan.update").Run(ctx, core.NewOptions(
//
//	core.Option{Key: "id", Value: "id-42-a3f2b1"},
//	core.Option{Key: "status", Value: "ready"},
//
// ))
func (s *PrepSubsystem) handlePlanUpdate(ctx context.Context, options core.Options) core.Result {
	_, output, err := s.planUpdate(ctx, nil, PlanUpdateInput{
		ID:          optionStringValue(options, "id", "_arg"),
		Slug:        optionStringValue(options, "slug"),
		Status:      optionStringValue(options, "status"),
		Title:       optionStringValue(options, "title"),
		Objective:   optionStringValue(options, "objective"),
		Description: optionStringValue(options, "description"),
		Context:     optionAnyMapValue(options, "context"),
		Phases:      planPhasesValue(options, "phases"),
		Notes:       optionStringValue(options, "notes"),
		Agent:       optionStringValue(options, "agent"),
		AgentType:   optionStringValue(options, "agent_type", "agent-type"),
	})
	if err != nil {
		return core.Result{Value: err, OK: false}
	}
	return core.Result{Value: output, OK: true}
}

// result := c.Action("plan.delete").Run(ctx, core.NewOptions(core.Option{Key: "id", Value: "id-42-a3f2b1"}))
func (s *PrepSubsystem) handlePlanDelete(ctx context.Context, options core.Options) core.Result {
	_, output, err := s.planDelete(ctx, nil, PlanDeleteInput{
		ID:     optionStringValue(options, "id", "_arg"),
		Slug:   optionStringValue(options, "slug"),
		Reason: optionStringValue(options, "reason"),
	})
	if err != nil {
		return core.Result{Value: err, OK: false}
	}
	return core.Result{Value: output, OK: true}
}

// result := c.Action("plan.list").Run(ctx, core.NewOptions(core.Option{Key: "repo", Value: "go-io"}))
func (s *PrepSubsystem) handlePlanList(ctx context.Context, options core.Options) core.Result {
	_, output, err := s.planList(ctx, nil, PlanListInput{
		Status: optionStringValue(options, "status"),
		Repo:   optionStringValue(options, "repo"),
		Limit:  optionIntValue(options, "limit"),
	})
	if err != nil {
		return core.Result{Value: err, OK: false}
	}
	return core.Result{Value: output, OK: true}
}

func (s *PrepSubsystem) registerPlanTools(server *mcp.Server) {
	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_create",
		Description: "Create an implementation plan. Plans track phased work with acceptance criteria, status lifecycle (draft → ready → in_progress → needs_verification → verified → approved), and per-phase progress.",
	}, s.planCreate)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_read",
		Description: "Read an implementation plan by ID. Returns the full plan with all phases, criteria, and status.",
	}, s.planRead)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_get",
		Description: "Read an implementation plan by slug with progress details and full phases.",
	}, s.planGetCompat)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_update",
		Description: "Update an implementation plan. Supports partial updates — only provided fields are changed. Use this to advance status, update phases, or add notes.",
	}, s.planUpdate)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_delete",
		Description: "Delete an implementation plan by ID. Permanently removes the plan file.",
	}, s.planDelete)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_list",
		Description: "List implementation plans. Supports filtering by status (draft, ready, in_progress, etc.) and repo.",
	}, s.planList)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_create",
		Description: "Create a plan using the slug-based compatibility surface described by the platform RFC.",
	}, s.planCreateCompat)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_read",
		Description: "Read a plan using the legacy plain-name MCP alias.",
	}, s.planRead)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_get",
		Description: "Read a plan by slug with progress details and full phases.",
	}, s.planGetCompat)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_list",
		Description: "List plans using the compatibility surface with slug and progress summaries.",
	}, s.planListCompat)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_check",
		Description: "Check whether a plan or phase is complete using the compatibility surface.",
	}, s.planCheck)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_check",
		Description: "Check whether a plan or phase is complete using the compatibility surface.",
	}, s.planCheck)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_update",
		Description: "Update a plan using the legacy plain-name MCP alias.",
	}, s.planUpdate)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_update_status",
		Description: "Update a plan lifecycle status by slug.",
	}, s.planUpdateStatusCompat)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_update_status",
		Description: "Update a plan lifecycle status by slug.",
	}, s.planUpdateStatusCompat)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_delete",
		Description: "Delete a plan using the legacy plain-name MCP alias.",
	}, s.planDelete)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_archive",
		Description: "Archive a plan by slug without deleting the local record.",
	}, s.planArchiveCompat)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_archive",
		Description: "Archive a plan by slug without deleting the local record.",
	}, s.planArchiveCompat)

	mcp.AddTool(server, &mcp.Tool{
		Name:        "plan_from_issue",
		Description: "Create an implementation plan from a tracked issue slug or ID.",
	}, s.planFromIssue)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_plan_from_issue",
		Description: "Create an implementation plan from a tracked issue slug or ID.",
	}, s.planFromIssue)
}

func (s *PrepSubsystem) planCreate(_ context.Context, _ *mcp.CallToolRequest, input PlanCreateInput) (*mcp.CallToolResult, PlanCreateOutput, error) {
	if input.Title == "" {
		return nil, PlanCreateOutput{}, core.E("planCreate", "title is required", nil)
	}
	description := input.Description
	if description == "" {
		description = input.Objective
	}
	objective := input.Objective
	if objective == "" {
		objective = description
	}
	if objective == "" {
		return nil, PlanCreateOutput{}, core.E("planCreate", "objective is required", nil)
	}

	id := planID()
	plan := Plan{
		ID:              id,
		Slug:            planSlugValue(input.Slug, input.Title, id),
		Title:           input.Title,
		Status:          "draft",
		Repo:            input.Repo,
		Org:             input.Org,
		Objective:       objective,
		Description:     description,
		AgentType:       core.Trim(input.AgentType),
		Context:         input.Context,
		TemplateVersion: input.TemplateVersion,
		Phases:          input.Phases,
		Notes:           input.Notes,
		CreatedAt:       time.Now(),
		UpdatedAt:       time.Now(),
	}
	if plan.AgentType == "" {
		plan.AgentType = core.Trim(plan.Agent)
	}
	plan = normalisePlan(plan)

	writeResult := writePlanResult(PlansRoot(), &plan)
	if !writeResult.OK {
		err, _ := writeResult.Value.(error)
		if err == nil {
			err = core.E("planCreate", "failed to write plan", nil)
		}
		return nil, PlanCreateOutput{}, err
	}
	path, ok := writeResult.Value.(string)
	if !ok {
		return nil, PlanCreateOutput{}, core.E("planCreate", "invalid plan write result", nil)
	}

	return nil, PlanCreateOutput{
		Success: true,
		ID:      id,
		Path:    path,
	}, nil
}

func (s *PrepSubsystem) planRead(_ context.Context, _ *mcp.CallToolRequest, input PlanReadInput) (*mcp.CallToolResult, PlanReadOutput, error) {
	ref := planReference(input.ID, input.Slug)
	if ref == "" {
		return nil, PlanReadOutput{}, core.E("planRead", "id is required", nil)
	}

	planResult := readPlanResult(PlansRoot(), ref)
	if !planResult.OK {
		err, _ := planResult.Value.(error)
		if err == nil {
			err = core.E("planRead", "failed to read plan", nil)
		}
		return nil, PlanReadOutput{}, err
	}
	plan, ok := planResult.Value.(*Plan)
	if !ok || plan == nil {
		return nil, PlanReadOutput{}, core.E("planRead", "invalid plan payload", nil)
	}

	return nil, PlanReadOutput{
		Success: true,
		Plan:    *plan,
	}, nil
}

func (s *PrepSubsystem) planUpdate(_ context.Context, _ *mcp.CallToolRequest, input PlanUpdateInput) (*mcp.CallToolResult, PlanUpdateOutput, error) {
	ref := planReference(input.ID, input.Slug)
	if ref == "" {
		return nil, PlanUpdateOutput{}, core.E("planUpdate", "id is required", nil)
	}

	planResult := readPlanResult(PlansRoot(), ref)
	if !planResult.OK {
		err, _ := planResult.Value.(error)
		if err == nil {
			err = core.E("planUpdate", "failed to read plan", nil)
		}
		return nil, PlanUpdateOutput{}, err
	}
	plan, ok := planResult.Value.(*Plan)
	if !ok || plan == nil {
		return nil, PlanUpdateOutput{}, core.E("planUpdate", "invalid plan payload", nil)
	}

	if input.Status != "" {
		if !validPlanStatus(input.Status) {
			return nil, PlanUpdateOutput{}, core.E("planUpdate", core.Concat("invalid status: ", input.Status, " (valid: draft, ready, in_progress, needs_verification, verified, approved)"), nil)
		}
		plan.Status = input.Status
	}
	if input.Title != "" {
		plan.Title = input.Title
	}
	if input.Slug != "" {
		plan.Slug = planSlugValue(input.Slug, plan.Title, plan.ID)
	}
	if input.Objective != "" {
		plan.Objective = input.Objective
		if plan.Description == "" {
			plan.Description = input.Objective
		}
	}
	if input.Description != "" {
		plan.Description = input.Description
		if plan.Objective == "" || input.Objective == "" {
			plan.Objective = input.Description
		}
	}
	if input.Context != nil {
		plan.Context = input.Context
	}
	if input.Phases != nil {
		plan.Phases = input.Phases
	}
	if input.Notes != "" {
		plan.Notes = input.Notes
	}
	if input.Agent != "" {
		plan.Agent = input.Agent
	}
	if input.AgentType != "" {
		plan.AgentType = input.AgentType
	}

	*plan = normalisePlan(*plan)
	plan.UpdatedAt = time.Now()

	writeResult := writePlanResult(PlansRoot(), plan)
	if !writeResult.OK {
		err, _ := writeResult.Value.(error)
		if err == nil {
			err = core.E("planUpdate", "failed to write plan", nil)
		}
		return nil, PlanUpdateOutput{}, err
	}

	return nil, PlanUpdateOutput{
		Success: true,
		Plan:    *plan,
	}, nil
}

func (s *PrepSubsystem) planDelete(_ context.Context, _ *mcp.CallToolRequest, input PlanDeleteInput) (*mcp.CallToolResult, PlanDeleteOutput, error) {
	plan, err := deletePlanResult(input, "id is required", "planDelete")
	if err != nil {
		return nil, PlanDeleteOutput{}, err
	}

	return nil, PlanDeleteOutput{
		Success: true,
		Deleted: plan.ID,
	}, nil
}

func (s *PrepSubsystem) planList(_ context.Context, _ *mcp.CallToolRequest, input PlanListInput) (*mcp.CallToolResult, PlanListOutput, error) {
	dir := PlansRoot()
	if r := fs.EnsureDir(dir); !r.OK {
		err, _ := r.Value.(error)
		return nil, PlanListOutput{}, core.E("planList", "failed to access plans directory", err)
	}

	limit := input.Limit
	if limit <= 0 {
		limit = planListDefaultLimit
	}

	jsonFiles := core.PathGlob(core.JoinPath(dir, "*.json"))

	var plans []Plan
	for _, f := range jsonFiles {
		id := core.TrimSuffix(core.PathBase(f), ".json")
		planResult := readPlanResult(dir, id)
		if !planResult.OK {
			continue
		}
		plan, ok := planResult.Value.(*Plan)
		if !ok || plan == nil {
			continue
		}

		if input.Status != "" && plan.Status != input.Status {
			continue
		}
		if input.Repo != "" && plan.Repo != input.Repo {
			continue
		}

		plans = append(plans, *plan)
		if len(plans) >= limit {
			break
		}
	}

	return nil, PlanListOutput{
		Success: true,
		Count:   len(plans),
		Plans:   plans,
	}, nil
}

func planPath(dir, id string) string {
	return core.JoinPath(dir, core.Concat(pathKey(id), ".json"))
}

func planPhasesValue(options core.Options, keys ...string) []Phase {
	for _, key := range keys {
		result := options.Get(key)
		if !result.OK {
			continue
		}
		phases := phaseSliceValue(result.Value)
		if len(phases) > 0 {
			return phases
		}
	}
	return nil
}

func phaseSliceValue(value any) []Phase {
	switch typed := value.(type) {
	case []Phase:
		return typed
	case []any:
		phases := make([]Phase, 0, len(typed))
		for _, item := range typed {
			phase, ok := phaseValue(item)
			if ok {
				phases = append(phases, phase)
			}
		}
		return phases
	case string:
		trimmed := core.Trim(typed)
		if trimmed == "" {
			return nil
		}
		if core.HasPrefix(trimmed, "[") {
			var phases []Phase
			if result := core.JSONUnmarshalString(trimmed, &phases); result.OK {
				return phases
			}
			if values := anyMapSliceValue(trimmed); len(values) > 0 {
				return phaseSliceValue(values)
			}
			var generic []any
			if result := core.JSONUnmarshalString(trimmed, &generic); result.OK {
				return phaseSliceValue(generic)
			}
		}
	case []map[string]any:
		phases := make([]Phase, 0, len(typed))
		for _, item := range typed {
			phase, ok := phaseValue(item)
			if ok {
				phases = append(phases, phase)
			}
		}
		return phases
	}
	if phase, ok := phaseValue(value); ok {
		return []Phase{phase}
	}
	return nil
}

func phaseValue(value any) (Phase, bool) {
	switch typed := value.(type) {
	case Phase:
		return typed, true
	case map[string]any:
		criteria := stringSliceValue(typed["criteria"])
		completionCriteria := phaseCriteriaValue(typed["completion_criteria"], typed["completion-criteria"])
		if len(criteria) == 0 {
			criteria = completionCriteria
		}
		if len(completionCriteria) == 0 {
			completionCriteria = criteria
		}
		return Phase{
			Number:             intValue(typed["number"]),
			Name:               stringValue(typed["name"]),
			Description:        stringValue(typed["description"]),
			Status:             stringValue(typed["status"]),
			Criteria:           criteria,
			CompletionCriteria: completionCriteria,
			Dependencies:       phaseDependenciesValue(typed["dependencies"]),
			Tasks:              planTaskSliceValue(typed["tasks"]),
			Checkpoints:        phaseCheckpointSliceValue(typed["checkpoints"]),
			Tests:              intValue(typed["tests"]),
			Notes:              stringValue(typed["notes"]),
		}, true
	case map[string]string:
		return phaseValue(anyMapValue(typed))
	case string:
		trimmed := core.Trim(typed)
		if trimmed == "" || !core.HasPrefix(trimmed, "{") {
			return Phase{}, false
		}
		if values := anyMapValue(trimmed); len(values) > 0 {
			return phaseValue(values)
		}
	}
	return Phase{}, false
}

func phaseDependenciesValue(value any) []string {
	switch typed := value.(type) {
	case []string:
		return cleanStrings(typed)
	case []any:
		dependencies := make([]string, 0, len(typed))
		for _, item := range typed {
			text, ok := item.(string)
			if !ok {
				return nil
			}
			if text = core.Trim(text); text != "" {
				dependencies = append(dependencies, text)
			}
		}
		return dependencies
	case string:
		trimmed := core.Trim(typed)
		if trimmed == "" {
			return nil
		}
		if core.HasPrefix(trimmed, "[") {
			var dependencies []string
			if result := core.JSONUnmarshalString(trimmed, &dependencies); result.OK {
				return cleanStrings(dependencies)
			}
			return nil
		}
		return cleanStrings(core.Split(trimmed, ","))
	default:
		if text := stringValue(value); text != "" {
			return []string{text}
		}
	}
	return nil
}

func phaseCriteriaValue(values ...any) []string {
	for _, value := range values {
		criteria := stringSliceValue(value)
		if len(criteria) > 0 {
			return criteria
		}
	}
	return nil
}

func planID() string {
	counter := planIDCounter.Add(1)
	suffix := planRandomHex()
	return core.Concat("id-", strconv.FormatUint(counter, 10), "-", suffix)
}

func planRandomHex() string {
	bytes := make([]byte, 3)
	if _, err := rand.Read(bytes); err != nil {
		return "000000"
	}
	return hex.EncodeToString(bytes)
}

func planTaskSliceValue(value any) []PlanTask {
	switch typed := value.(type) {
	case []PlanTask:
		return typed
	case []string:
		tasks := make([]PlanTask, 0, len(typed))
		for _, title := range cleanStrings(typed) {
			tasks = append(tasks, PlanTask{Title: title})
		}
		return tasks
	case []any:
		tasks := make([]PlanTask, 0, len(typed))
		for _, item := range typed {
			if task, ok := planTaskValue(item); ok {
				tasks = append(tasks, task)
			}
		}
		return tasks
	case string:
		trimmed := core.Trim(typed)
		if trimmed == "" {
			return nil
		}
		if core.HasPrefix(trimmed, "[") {
			var tasks []PlanTask
			if result := core.JSONUnmarshalString(trimmed, &tasks); result.OK {
				return tasks
			}
			var generic []any
			if result := core.JSONUnmarshalString(trimmed, &generic); result.OK {
				return planTaskSliceValue(generic)
			}
			var titles []string
			if result := core.JSONUnmarshalString(trimmed, &titles); result.OK {
				return planTaskSliceValue(titles)
			}
		}
	case []map[string]any:
		tasks := make([]PlanTask, 0, len(typed))
		for _, item := range typed {
			if task, ok := planTaskValue(item); ok {
				tasks = append(tasks, task)
			}
		}
		return tasks
	}
	if task, ok := planTaskValue(value); ok {
		return []PlanTask{task}
	}
	return nil
}

func planTaskValue(value any) (PlanTask, bool) {
	switch typed := value.(type) {
	case PlanTask:
		return typed, true
	case map[string]any:
		title := stringValue(typed["title"])
		if title == "" {
			title = stringValue(typed["name"])
		}
		file := stringValue(typed["file"])
		if file == "" {
			file = stringValue(typed["file_ref"])
		}
		line := intValue(typed["line"])
		if line == 0 {
			line = intValue(typed["line_ref"])
		}
		return PlanTask{
			ID:          stringValue(typed["id"]),
			Title:       title,
			Description: stringValue(typed["description"]),
			Priority:    stringValue(typed["priority"]),
			Category:    stringValue(typed["category"]),
			Status:      stringValue(typed["status"]),
			Notes:       stringValue(typed["notes"]),
			File:        file,
			Line:        line,
			FileRef:     file,
			LineRef:     line,
		}, title != ""
	case map[string]string:
		return planTaskValue(anyMapValue(typed))
	case string:
		title := core.Trim(typed)
		if title == "" {
			return PlanTask{}, false
		}
		if core.HasPrefix(title, "{") {
			if values := anyMapValue(title); len(values) > 0 {
				return planTaskValue(values)
			}
		}
		return PlanTask{Title: title}, true
	}
	return PlanTask{}, false
}

func phaseCheckpointSliceValue(value any) []PhaseCheckpoint {
	switch typed := value.(type) {
	case []PhaseCheckpoint:
		return typed
	case []any:
		checkpoints := make([]PhaseCheckpoint, 0, len(typed))
		for _, item := range typed {
			if checkpoint, ok := phaseCheckpointValue(item); ok {
				checkpoints = append(checkpoints, checkpoint)
			}
		}
		return checkpoints
	case string:
		trimmed := core.Trim(typed)
		if trimmed == "" {
			return nil
		}
		if core.HasPrefix(trimmed, "[") {
			var checkpoints []PhaseCheckpoint
			if result := core.JSONUnmarshalString(trimmed, &checkpoints); result.OK {
				return checkpoints
			}
			var generic []any
			if result := core.JSONUnmarshalString(trimmed, &generic); result.OK {
				return phaseCheckpointSliceValue(generic)
			}
		}
	case []map[string]any:
		checkpoints := make([]PhaseCheckpoint, 0, len(typed))
		for _, item := range typed {
			if checkpoint, ok := phaseCheckpointValue(item); ok {
				checkpoints = append(checkpoints, checkpoint)
			}
		}
		return checkpoints
	}
	if checkpoint, ok := phaseCheckpointValue(value); ok {
		return []PhaseCheckpoint{checkpoint}
	}
	return nil
}

func phaseCheckpointValue(value any) (PhaseCheckpoint, bool) {
	switch typed := value.(type) {
	case PhaseCheckpoint:
		return typed, typed.Note != ""
	case map[string]any:
		note := stringValue(typed["note"])
		return PhaseCheckpoint{
			Note:      note,
			Context:   anyMapValue(typed["context"]),
			CreatedAt: stringValue(typed["created_at"]),
		}, note != ""
	case map[string]string:
		return phaseCheckpointValue(anyMapValue(typed))
	case string:
		note := core.Trim(typed)
		if note == "" {
			return PhaseCheckpoint{}, false
		}
		if core.HasPrefix(note, "{") {
			if values := anyMapValue(note); len(values) > 0 {
				return phaseCheckpointValue(values)
			}
		}
		return PhaseCheckpoint{Note: note}, true
	}
	return PhaseCheckpoint{}, false
}

func phaseCriteriaList(phase Phase) []string {
	criteria := cleanStrings(phase.Criteria)
	completionCriteria := cleanStrings(phase.CompletionCriteria)

	if len(criteria) == 0 {
		return completionCriteria
	}
	if len(completionCriteria) == 0 {
		return criteria
	}

	merged := make([]string, 0, len(criteria)+len(completionCriteria))
	seen := map[string]bool{}
	for _, value := range criteria {
		if seen[value] {
			continue
		}
		seen[value] = true
		merged = append(merged, value)
	}
	for _, value := range completionCriteria {
		if seen[value] {
			continue
		}
		seen[value] = true
		merged = append(merged, value)
	}
	return merged
}

// result := readPlanResult(PlansRoot(), "plan-id")
// if result.OK { plan := result.Value.(*Plan) }
func readPlanResult(dir, id string) core.Result {
	path := planPath(dir, id)
	r := fs.Read(path)
	if r.OK {
		return planFromReadResult(r, id)
	}

	if found := findPlanBySlugResult(dir, id); found.OK {
		return found
	}

	err, _ := r.Value.(error)
	if err == nil {
		return core.Result{Value: core.E("readPlan", core.Concat("plan not found: ", id), nil), OK: false}
	}
	return core.Result{Value: core.E("readPlan", core.Concat("plan not found: ", id), err), OK: false}
}

// plan, err := readPlan(PlansRoot(), "plan-id")
func readPlan(dir, id string) (*Plan, error) {
	r := readPlanResult(dir, id)
	if !r.OK {
		err, _ := r.Value.(error)
		if err == nil {
			return nil, core.E("readPlan", "failed to read plan", nil)
		}
		return nil, err
	}
	plan, ok := r.Value.(*Plan)
	if !ok || plan == nil {
		return nil, core.E("readPlan", "invalid plan payload", nil)
	}
	return plan, nil
}

// result := writePlanResult(PlansRoot(), plan)
// if result.OK { path := result.Value.(string) }
func writePlanResult(dir string, plan *Plan) core.Result {
	if plan == nil {
		return core.Result{Value: core.E("writePlan", "plan is required", nil), OK: false}
	}
	normalised := normalisePlan(*plan)
	plan = &normalised
	if r := fs.EnsureDir(dir); !r.OK {
		err, _ := r.Value.(error)
		if err == nil {
			return core.Result{Value: core.E("writePlan", "failed to create plans directory", nil), OK: false}
		}
		return core.Result{Value: core.E("writePlan", "failed to create plans directory", err), OK: false}
	}

	path := planPath(dir, plan.ID)

	if r := fs.WriteAtomic(path, core.JSONMarshalString(plan)); !r.OK {
		err, _ := r.Value.(error)
		if err == nil {
			return core.Result{Value: core.E("writePlan", "failed to write plan", nil), OK: false}
		}
		return core.Result{Value: core.E("writePlan", "failed to write plan", err), OK: false}
	}
	return core.Result{Value: path, OK: true}
}

// path, err := writePlan(PlansRoot(), plan)
func writePlan(dir string, plan *Plan) (string, error) {
	r := writePlanResult(dir, plan)
	if !r.OK {
		err, _ := r.Value.(error)
		if err == nil {
			return "", core.E("writePlan", "failed to write plan", nil)
		}
		return "", err
	}
	path, ok := r.Value.(string)
	if !ok {
		return "", core.E("writePlan", "invalid plan write result", nil)
	}
	return path, nil
}

func validPlanStatus(status string) bool {
	switch status {
	case "draft", "ready", "in_progress", "needs_verification", "verified", "approved":
		return true
	}
	return false
}

func normalisePlan(plan Plan) Plan {
	if plan.Slug == "" {
		plan.Slug = planSlugValue("", plan.Title, plan.ID)
	}
	if plan.Description == "" {
		plan.Description = plan.Objective
	}
	if plan.Objective == "" {
		plan.Objective = plan.Description
	}
	if plan.AgentType == "" {
		plan.AgentType = plan.Agent
	}
	if plan.Agent == "" {
		plan.Agent = plan.AgentType
	}
	for i := range plan.Phases {
		plan.Phases[i] = normalisePhase(plan.Phases[i], i+1)
	}
	return plan
}

func normalisePhase(phase Phase, number int) Phase {
	if phase.Number == 0 {
		phase.Number = number
	}
	if phase.Status == "" {
		phase.Status = "pending"
	}
	criteria := phaseCriteriaList(phase)
	phase.Criteria = criteria
	phase.CompletionCriteria = criteria
	for i := range phase.Tasks {
		phase.Tasks[i] = normalisePlanTask(phase.Tasks[i], i+1)
	}
	for i := range phase.Checkpoints {
		if phase.Checkpoints[i].CreatedAt == "" {
			phase.Checkpoints[i].CreatedAt = time.Now().Format(time.RFC3339)
		}
	}
	return phase
}

func normalisePlanTask(task PlanTask, index int) PlanTask {
	if task.ID == "" {
		task.ID = core.Sprint(index)
	}
	if task.Status == "" {
		task.Status = "pending"
	}
	if task.Title == "" {
		task.Title = task.Description
	}
	task.Priority = core.Trim(task.Priority)
	task.Category = core.Trim(task.Category)
	if task.File == "" {
		task.File = task.FileRef
	}
	if task.FileRef == "" {
		task.FileRef = task.File
	}
	if task.Line == 0 {
		task.Line = task.LineRef
	}
	if task.LineRef == 0 {
		task.LineRef = task.Line
	}
	return task
}

func planReference(id, slug string) string {
	if id != "" {
		return id
	}
	return slug
}

func planFromReadResult(result core.Result, ref string) core.Result {
	var plan Plan
	if ur := core.JSONUnmarshalString(result.Value.(string), &plan); !ur.OK {
		err, _ := ur.Value.(error)
		if err == nil {
			return core.Result{Value: core.E("readPlan", core.Concat("failed to parse plan ", ref), nil), OK: false}
		}
		return core.Result{Value: core.E("readPlan", core.Concat("failed to parse plan ", ref), err), OK: false}
	}
	normalised := normalisePlan(plan)
	return core.Result{Value: &normalised, OK: true}
}

func findPlanBySlugResult(dir, slug string) core.Result {
	ref := core.Trim(slug)
	if ref == "" {
		return core.Result{Value: core.E("readPlan", "plan not found: invalid", nil), OK: false}
	}

	for _, path := range core.PathGlob(core.JoinPath(dir, "*.json")) {
		result := fs.Read(path)
		if !result.OK {
			continue
		}
		planResult := planFromReadResult(result, ref)
		if !planResult.OK {
			continue
		}
		plan, ok := planResult.Value.(*Plan)
		if !ok || plan == nil {
			continue
		}
		if plan.Slug == ref || plan.ID == ref {
			return core.Result{Value: plan, OK: true}
		}
	}

	return core.Result{Value: core.E("readPlan", core.Concat("plan not found: ", ref), nil), OK: false}
}

func planSlugValue(input, title, id string) string {
	slug := cleanPlanSlug(input)
	if slug != "" {
		return slug
	}

	base := cleanPlanSlug(title)
	if base == "" {
		base = "plan"
	}
	suffix := planSlugSuffix(id)
	if suffix == "" {
		return base
	}
	return core.Concat(base, "-", suffix)
}

func cleanPlanSlug(value string) string {
	slug := core.Lower(core.Trim(value))
	if slug == "" {
		return ""
	}
	for _, old := range []string{"/", "\\", "_", ".", ":", ";", ",", " ", "\t", "\n", "\r"} {
		slug = core.Replace(slug, old, "-")
	}
	for core.Contains(slug, "--") {
		slug = core.Replace(slug, "--", "-")
	}
	for core.HasPrefix(slug, "-") {
		slug = slug[1:]
	}
	for core.HasSuffix(slug, "-") {
		slug = slug[:len(slug)-1]
	}
	if slug == "" || slug == "invalid" {
		return ""
	}
	return slug
}

func planSlugSuffix(id string) string {
	parts := core.Split(id, "-")
	if len(parts) == 0 {
		return ""
	}
	return core.Trim(parts[len(parts)-1])
}