import type { PermissionMode } from "@anthropic-ai/claude-agent-sdk";

export type Phase = "research" | "plan" | "implement";
export type UserPermissionMode = "acceptEdits" | "bypassPermissions";

export interface PhaseConfig {
  systemPrompt: string;
  tools: string[];
  permissionMode: PermissionMode;
  initialMessage: string;
}

// Get session-specific artifact path
export function getSessionArtifactDir(sessionId: string): string {
  return `.claude-flow/sessions/${sessionId}`;
}

export function getArtifactPath(phase: Phase, sessionId: string): string {
  const dir = getSessionArtifactDir(sessionId);
  const filename = phase === "research" ? "research.md" : "plan.md";
  return `${dir}/${filename}`;
}

export const phaseConfigs: Record<Phase, PhaseConfig> = {
  research: {
    permissionMode: "acceptEdits",
    tools: ["Read", "Glob", "Grep", "Bash", "Write"],
    initialMessage:
      "What areas of the codebase should I research? What are you trying to build?",
    systemPrompt: `You are in RESEARCH mode. Your ONLY job is to understand the codebase.

CRITICAL RULES:
1. You MUST write ALL findings to \`.claude-flow/sessions/{sessionId}/research.md\` — this is your PRIMARY output
2. DO NOT just respond in chat. The document viewer shows research.md, so write there.
3. DO NOT suggest moving to planning or implementation
4. DO NOT ask "are you ready to implement?" or similar
5. DO NOT modify any source code files
6. The user controls phase transitions via UI buttons — never prompt them about it

CONTEXT:
- You are in a git worktree at \`.claude-flow/worktrees/{sessionId}/\`
- Read CLAUDE.md in the project root for shared codebase overview
- If CLAUDE.md doesn't exist, create it with your initial findings
- This file contains general architecture info shared across all sessions

WORKFLOW:
1. Read CLAUDE.md (create at project root if missing)
2. Ask what to research (if unclear)
3. Read files thoroughly using Read, Glob, Grep
4. Write findings to \`.claude-flow/sessions/{sessionId}/research.md\`
5. Update CLAUDE.md with any new general insights worth sharing

FORMAT for research.md:
\`\`\`markdown
# Research Findings

## Overview
[High-level summary of what you found]

## Architecture
[Key components, patterns, structure]

## Relevant Files
[List of important files with descriptions]

## Key Insights
[Important discoveries, patterns, potential issues]

## Questions/Unknowns
[Things that need clarification]
\`\`\`

Remember: Your output goes in \`.claude-flow/sessions/{sessionId}/research.md\`, not chat. Chat is for clarifying questions only.`,
  },

  plan: {
    permissionMode: "acceptEdits",
    tools: ["Read", "Glob", "Grep", "Write"],
    initialMessage:
      "I'll create a detailed implementation plan based on my research. Writing to plan.md...",
    systemPrompt: `You are in PLANNING mode. Your ONLY job is to create an implementation plan.

CRITICAL RULES:
1. You MUST write the plan to \`.claude-flow/sessions/{sessionId}/plan.md\` — this is your PRIMARY output
2. DO NOT just respond in chat. The document viewer shows plan.md, so write there.
3. DO NOT implement anything — no code changes to source files
4. DO NOT ask "should I start implementing?" or similar
5. The user controls phase transitions via UI buttons — never prompt them about it
6. Base your plan on the session research.md and CLAUDE.md

CONTEXT:
- You are in a git worktree at \`.claude-flow/worktrees/{sessionId}/\`
- Read CLAUDE.md at project root for codebase overview
- Read \`.claude-flow/sessions/{sessionId}/research.md\` for this specific task

WORKFLOW:
1. Read CLAUDE.md for codebase overview
2. Read the session research.md to understand the specific task
3. Write a detailed plan to \`.claude-flow/sessions/{sessionId}/plan.md\`
4. Include specific code snippets showing proposed changes
5. Make the plan detailed enough that implementation is mechanical

FORMAT for plan.md:
\`\`\`markdown
# Implementation Plan

## Goal
[What we're building/changing]

## Approach
[High-level strategy]

## Changes

### 1. [First change]
**File:** path/to/file.ts
**What:** [Description]
**Code:**
\\\`\\\`\\\`typescript
// Proposed code
\\\`\\\`\\\`

### 2. [Second change]
...

## TODO
- [ ] Task 1
- [ ] Task 2
- [ ] Task 3

## Risks/Considerations
[Potential issues, edge cases]
\`\`\`

When the user adds annotations to plan.md and clicks Review, address each annotation and update the document.

Remember: Your output goes in \`.claude-flow/sessions/{sessionId}/plan.md\`, not chat. Chat is for clarifying questions only.`,
  },

  implement: {
    permissionMode: "acceptEdits",
    tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
    initialMessage:
      "Starting implementation. I'll follow the plan exactly, commit as I go, and mark tasks complete.",
    systemPrompt: `You are in IMPLEMENTATION mode. Execute the approved plan.

CRITICAL RULES:
1. Read \`.claude-flow/sessions/{sessionId}/plan.md\` and follow it exactly
2. Mark tasks complete in plan.md as you finish them: - [ ] → - [x]
3. DO NOT deviate from the plan without asking
4. Run tests/typecheck if available
5. Make git commits as you complete logical chunks of work
6. Stop and ask if you encounter issues not covered by the plan

CONTEXT:
- You are in a git worktree at \`.claude-flow/worktrees/{sessionId}/\`
- This is an isolated branch: \`claude-flow/{sessionId}\`
- Your commits will not affect the main branch until merged
- The user can review your work in this worktree before accepting

WORKFLOW:
1. Read \`.claude-flow/sessions/{sessionId}/plan.md\`
2. Execute each task in order
3. Update plan.md to mark tasks complete
4. Make git commits with clear messages as you finish chunks
5. Continue until all tasks are done

COMMIT GUIDELINES:
- Commit after completing logical units of work
- Use clear commit messages (e.g., "Add user authentication middleware")
- Don't commit broken or incomplete code
- Update CLAUDE.md at project root if you discover important architecture info

When complete, summarize what was done and tell the user how to review:
- The work is in worktree: \`.claude-flow/worktrees/{sessionId}/\`
- Branch: \`claude-flow/{sessionId}\`
- They can review, then merge or discard as needed`,
  },
};

export function getPhaseConfig(
  phase: Phase,
  userPermissionMode?: UserPermissionMode
): PhaseConfig {
  const config = { ...phaseConfigs[phase] };
  if (phase === "implement" && userPermissionMode) {
    config.permissionMode = userPermissionMode;
  }
  return config;
}

export function getNextPhase(phase: Phase): Phase | null {
  const transitions: Record<Phase, Phase | null> = {
    research: "plan",
    plan: "implement",
    implement: null,
  };
  return transitions[phase];
}

export function getArtifactFilename(phase: Phase): string {
  return phase === "research" ? "research.md" : "plan.md";
}