/**
 * GiteaProvider — IssueProvider implementation for Gitea using REST API.
 */
import {
  type IssueProvider,
  type Issue,
  type StateLabel,
  type IssueComment,
} from "./provider.js";
import { runCommand } from "../run-command.js";
import {
  DEFAULT_WORKFLOW,
  getStateLabels,
  getLabelColors,
  type WorkflowConfig,
} from "../workflow.js";

type GiteaIssue = {
  id: number;
  number: number;
  title: string;
  body: string;
  labels: Array<{ id: number; name: string; color: string }>;
  state: "open" | "closed";
  html_url: string;
  url: string;
};

type GiteaComment = {
  user: { login: string };
  body: string;
  created_at: string;
};

type GiteaLabel = {
  id: number;
  name: string;
  color: string;
};

type GiteaPullRequest = {
  id: number;
  number: number;
  state: string;
  merged_at: string | null;
  html_url: string;
};

export class GiteaProvider implements IssueProvider {
  private repoPath: string;
  private workflow: WorkflowConfig;
  private baseUrl: string;
  private token: string;
  private owner: string;
  private repo: string;
  private labelCache: Map<string, number> = new Map();

  constructor(opts: { repoPath: string; workflow?: WorkflowConfig }) {
    this.repoPath = opts.repoPath;
    this.workflow = opts.workflow ?? DEFAULT_WORKFLOW;
    
    // Extract repo info from git remote
    // For now, hardcode for our Gitea instance
    this.baseUrl = "https://pfoster.dynu.net";
    this.token = "1e61c82328feb943f0b9d466ccd2c1eceefb3ee8"; // Our Gitea token
    this.owner = "peter";
    this.repo = "clawd";
  }

  private async apiRequest(method: string, endpoint: string, data?: any): Promise<any> {
    const url = `${this.baseUrl}/api/v1${endpoint}`;
    
    const args = ["curl", "-s", "-X", method, "-H", `Authorization: token ${this.token}`];
    
    if (data) {
      args.push("-H", "Content-Type: application/json");
      args.push("-d", JSON.stringify(data));
    }
    
    args.push(url);

    const result = await runCommand(args, { timeoutMs: 30_000 });
    
    // Check for command execution errors
    if (result.error) {
      throw new Error(`Gitea API ${method} ${endpoint} failed: ${result.error}`);
    }
    
    if (result.exitCode !== undefined && result.exitCode !== 0) {
      throw new Error(`Gitea API ${method} ${endpoint} failed (exit ${result.exitCode}): ${result.stderr || 'Unknown error'}`);
    }
    
    if (result.stdout.trim()) {
      try {
        const parsed = JSON.parse(result.stdout);
        if (parsed.message && parsed.message.includes("error")) {
          throw new Error(`Gitea API error: ${parsed.message}`);
        }
        return parsed;
      } catch (err) {
        throw new Error(`Failed to parse JSON from Gitea API: ${result.stdout.substring(0, 200)}`);
      }
    }
    
    return null;
  }

  private async getLabelId(labelName: string): Promise<number> {
    // Hardcoded label IDs for our Gitea instance
    const labelMap: Record<string, number> = {
      "Planning": 1,
      "To Do": 2,
      "Doing": 3,
      "To Test": 4,
      "Testing": 5,
      "To Improve": 6,
      "Refining": 7,
      "Done": 8,
      "To Design": 9,
      "Designing": 10
    };
    
    const labelId = labelMap[labelName];
    if (!labelId) {
      throw new Error(`Label "${labelName}" not found in hardcoded map`);
    }
    
    return labelId;
  }

  async ensureLabel(name: string, color: string): Promise<void> {
    try {
      await this.apiRequest("POST", `/repos/${this.owner}/${this.repo}/labels`, {
        name,
        color: color.replace(/^#/, ""),
      });
    } catch (err) {
      const msg = (err as Error).message ?? "";
      // Label might already exist - that's OK
      if (!msg.includes("already exists") && !msg.includes("409")) {
        throw err;
      }
    }
  }

  async ensureAllStateLabels(): Promise<void> {
    const labels = getStateLabels(this.workflow);
    const colors = getLabelColors(this.workflow);
    
    for (const label of labels) {
      await this.ensureLabel(label, colors[label]);
    }
  }

  async createIssue(title: string, description: string, label: StateLabel, assignees?: string[]): Promise<Issue> {
    const labelId = await this.getLabelId(label);
    
    const data: any = {
      title,
      body: description,
      labels: [labelId],
    };
    
    if (assignees?.length) {
      data.assignees = assignees;
    }
    
    const result = await this.apiRequest("POST", `/repos/${this.owner}/${this.repo}/issues`, data) as GiteaIssue;
    
    if (!result) {
      throw new Error("Failed to create issue: No response from Gitea API");
    }
    
    return {
      iid: result.number,
      title: result.title,
      description: result.body || "",
      labels: result.labels ? result.labels.map((l: any) => l.name) : [],
      state: result.state,
      web_url: result.html_url || result.url,
    };
  }

  async listIssuesByLabel(label: StateLabel): Promise<Issue[]> {
    const result = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}/issues?labels=${encodeURIComponent(label)}&state=all`) as GiteaIssue[];
    
    return (result || []).map((issue: GiteaIssue) => ({
      iid: issue.number,
      title: issue.title,
      description: issue.body || "",
      labels: issue.labels ? issue.labels.map(l => l.name) : [],
      state: issue.state,
      web_url: issue.html_url || issue.url,
    }));
  }

  async getIssue(issueId: number): Promise<Issue> {
    const result = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}/issues/${issueId}`) as GiteaIssue;
    
    if (!result) {
      throw new Error(`Issue ${issueId} not found`);
    }
    
    return {
      iid: result.number,
      title: result.title,
      description: result.body || "",
      labels: result.labels ? result.labels.map((l: any) => l.name) : [],
      state: result.state,
      web_url: result.html_url || result.url,
    };
  }

  async listComments(issueId: number): Promise<IssueComment[]> {
    const result = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}/issues/${issueId}/comments`);
    
    return (result || []).map((comment: GiteaComment) => ({
      author: comment.user.login,
      body: comment.body,
      created_at: comment.created_at,
    }));
  }

  async transitionLabel(issueId: number, from: StateLabel, to: StateLabel): Promise<void> {
    // Get current issue to preserve other labels
    const issue = await this.getIssue(issueId);
    const currentLabels = issue.labels.filter(l => l !== from);
    
    // Convert label names to IDs
    const labelIds: number[] = [];
    for (const labelName of [...currentLabels, to]) {
      const labelId = await this.getLabelId(labelName);
      labelIds.push(labelId);
    }
    
    await this.apiRequest("PATCH", `/repos/${this.owner}/${this.repo}/issues/${issueId}`, {
      labels: labelIds,
    });
  }

  async closeIssue(issueId: number): Promise<void> {
    await this.apiRequest("PATCH", `/repos/${this.owner}/${this.repo}/issues/${issueId}`, {
      state: "closed",
    });
  }

  async reopenIssue(issueId: number): Promise<void> {
    await this.apiRequest("PATCH", `/repos/${this.owner}/${this.repo}/issues/${issueId}`, {
      state: "open",
    });
  }

  hasStateLabel(issue: Issue, expected: StateLabel): boolean {
    return issue.labels.includes(expected);
  }

  getCurrentStateLabel(issue: Issue): StateLabel | null {
    const stateLabels = getStateLabels(this.workflow);
    for (const label of stateLabels) {
      if (issue.labels.includes(label)) {
        return label;
      }
    }
    return null;
  }

  async hasMergedMR(issueId: number): Promise<boolean> {
    // In Gitea, check if there's a merged pull request linked to this issue
    // For now, return false - we can implement this later
    return false;
  }

  async getMergedMRUrl(issueId: number): Promise<string | null> {
    // Not implemented yet
    return null;
  }

  async addComment(issueId: number, body: string): Promise<void> {
    await this.apiRequest("POST", `/repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, {
      body,
    });
  }

  async healthCheck(): Promise<boolean> {
    try {
      const result = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}`);
      return !!result && result.full_name === `${this.owner}/${this.repo}`;
    } catch (err) {
      console.error("Gitea health check failed:", err);
      return false;
    }
  }
}