#!/usr/bin/env node

import {Ai} from '@ztimson/ai-utils';
import * as os from 'node:os';
import * as dotenv from 'dotenv';
import * as fs from 'node:fs';
import * as path from 'node:path';

dotenv.config({quiet: true, debug: false});
dotenv.config({path: '.env.local', override: true, quiet: true, debug: false});

(async () => {
	let p = process.argv[process.argv.length - 1];
	if(p === 'refine' || p.endsWith('refine.mjs')) p = null;
	if(!/^(\/|[A-Z]:)/m.test(p)) p = path.join(process.cwd(), p);

	const git = process.env['GIT_HOST'],
		owner = process.env['GIT_OWNER'],
		repo = process.env['GIT_REPO'],
		auth = process.env['GIT_TOKEN'],
		ticket = process.env['TICKET'],
		host = process.env['AI_HOST'],
		model = process.env['AI_MODEL'],
		labelDupe = process.env['LABELS_DUPE'] || 'Review/Duplicate',
		labelEnabled = process.env['LABEL_ENABLED'] || 'Review/AI',
		labelsReq = process.env['LABELS_REQ'] || 'Kind/Aesthetic,Kind/Bug,Kind/DevOps,Kind/Document,Kind/Enhancement,Kind/Refactor,Kind/Security',
		labelsOpt = process.env['LABELS_OPT'] || 'Breaking,Priority,QA',
		token = process.env['AI_TOKEN'];

	console.log(`Processing issue #${ticket}`);

	// Fetch issue
	const issueData = await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}`, {
		headers: {'Authorization': `token ${auth}`}
	}).then(async resp => {
		if(resp.ok) return  resp.json();
		else throw new Error(`${resp.status} ${await resp.text()}`);
	});
	if(issueData.labels?.length !== 1 || issueData.labels[0]?.name !== labelEnabled) {
		console.log('Skipping');
		return process.exit();
	}

	// Gather readme & template
	let title = '', type = '', labels = [], readme = '', readmeP = path.join(process.cwd(), 'README.md');
	if(fs.existsSync(readmeP)) readme = fs.readFileSync(readmeP, 'utf-8');
	const template = p ? fs.readFileSync(p, 'utf-8') : `## Description

A clear explanation of the request

---

## Current Behavior

what's happening now or the current state/gap

## Expected Behavior

What should happen instead

## Steps to Reproduce / Desired Flow

1. First step
2. Second step
3. Third step

## Additional Context

Logs, screenshots, links, related issues

## Acceptance Criteria

- [ ] Todo requirement
- [X] Completed requirement

## Technical Notes

Implementation details, constraints, dependencies, design decisions


| Effort / Weight | Score    |
|-----------------|----------|
| Size            | 0-5      |
| Complexity      | 0-5      |
| Unknowns        | 0-5      |
| **Total**       | **0-15** |
`;

	// Create AI
	let options = {ollama: {model, host}};
	if(host === 'anthropic') options = {anthropic: {model, token}};
	else if(host === 'openai') options = {openAi: {model, token}};
	const ai = new Ai({
		...options,
		model: [host, model],
		path: process.env['path'] || os.tmpdir(),
		tools: [{
			name: 'title',
			description: 'Set the ticket title, must be called EXACTLY ONCE',
			args: {title: {type: 'string', description: 'Ticket title, must match format: Module - Verb noun', required: true}},
			fn: (args) => title = args.title
		}, {
			name: 'add_label',
			description: 'Add a label to the ticket',
			args: {label: {type: 'string', description: 'Label name', required: true}},
			fn: async (args) => {
				labels.push(args.label);
				fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}/labels`, {
					method: 'POST',
					headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
					body: `{"labels":["${args.label}"]}`
				}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
			}
		}],
		system: `Transform raw tickets into structured markdown following the template EXACTLY.

**MANDATORY STEPS:**
1. Call \`title\` tool EXACTLY ONCE in format: "[Module] - [Verb] [subject]" (example: Storage - fix file uploads)
2. Identify one label from each group which best applies to the ticket: ${labelsReq.replace(',', ', ')}
3. Call the \`add_label\` tool ONCE FOR EVERY LABEL identified in the previous step
4. Filter the following labels to any that apply to this ticket: ${labelsOpt.replace(',', ', ')}
5. Call the \`add_label\` tool ONCE FOR EVERY LABEL identified in the previous step
6. Output the new ticket description in formated markdown matching the following rules:

**TEMPLATE RULES:**
- Use ## headers (match template exactly)
- Description: Clear summary of the request
- Current Behavior: What's happening now (remove for Document tickets)
- Expected Behavior: What should happen (remove for Document tickets)
- Steps to Reproduce: Numbered list for bugs, flow for enhancements, remove if not applicable
- Additional Context: Logs, screenshots, links provided by user
- Acceptance Criteria: Convert to checkboxes (- [ ] format)
- Technical Notes: Implementation approach, constraints, dependencies
- Weight table (use exact format below):

| Effort / Weight | Score    |
|-----------------|----------|
| Size            | 0-5      |
| Complexity      | 0-5      |
| Unknowns        | 0-5      |
| **Total**       | **0-15** |

**SCORING:**
- Size: # of modules/layers/files affected
- Complexity: Technical difficulty
- Unknowns: Research/uncertainty needed

**PROJECT README:**
\`\`\`markdown
${readme.trim() || 'No README available'}
\`\`\`

**TEMPLATE:**
\`\`\`markdown
${template.trim()}
\`\`\`

Output ONLY markdown. No explanations, labels, or extra formatting.`});

	// Format ticket with AI
	const messages = await ai.language.ask(`Title: ${issueData.title}\n\nDescription:\n${issueData.body || 'No description provided'}`).catch(() => []);
	const body = messages?.pop()?.content;
	if(!body) throw new Error('Invalid response from AI');

	// Check for duplicates
	const repoInfo = await fetch(`${git}/api/v1/repos/${owner}/${repo}`, {headers: {'Authorization': `token ${auth}`},}).then(resp => resp.ok ? resp.json() : null);
	const search = await fetch(`${git}/api/v1/repos/issues/search`, {
		method: 'POST',
		headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
		body: JSON.stringify({
			owner,
			priority_repo_id: repoInfo.id,
			type: 'issues',
			limit: 3,
			q: title
		})
	}).then(resp => resp.ok ? resp.json() : []);
	let dupeId = null;
	const dupeIds = search.map(t => t.id);
	const dupes = search.map(t => `ID: ${t.id}\nTitle: ${t.title}\n\`\`\`markdown\n${t.body}\n\`\`\``).join('\n\n');
	const hasDuplicates = (await ai.language.ask(`ID: ${issueData.id}\nTitle: ${title}\n\`\`\`markdown\n${body}\n\`\`\``, {
		system: `Your job is to identify duplicates. Respond ONLY with the duplicate's ID number or "NONE" if no match exists\n\n${dupes}`
	}))?.pop()?.content;
	// Handle duplicates
	if(hasDuplicates && hasDuplicates !== 'NONE' && (dupeId = dupeIds.find(id => id === hasDuplicates.trim()))) {
		await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}/comments`, {
			method: 'POST',
			headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
			body: `{"body": "Duplicate of #${dupeId}"}`
		}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
		await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}/labels`, {
			method: 'POST',
			headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
			body: `{"labels":["${labelDupe}"]}`
		}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
		await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}`, {
			method: 'PATCH',
			headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
			body: '{"state": "closed"}'
		}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
		console.log('Duplicate');
		return process.exit();
	}

	// Update ticket
	await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}`, {
		method: 'PATCH',
		headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
		body: JSON.stringify({title, body})
	}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });

	console.log(`Title: ${title}\nLabels: ${labels.join(', ')}\nBody:\n${body}`);
})().catch(err => {
	console.error(`Error: ${err.message || err.toString()}`);
	process.exit(1);
});