#!/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});
dotenv.config({path: '.env.local', override: true, quiet: true});

(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'],
		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] !== 'Review/AI') {
		console.log('Skipping');
		return process.exit();
	}

	// Gather readme & template
	let title = '', type = '', 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: 'type',
			description: 'Set the ticket type, must be called EXACTLY ONCE',
			args: {type: {type: 'string', description: 'Ticket type', enum: ['Bug', 'DevOps', 'Document', 'Enhancement', 'Refactor', 'Security'], required: true}},
			fn: (args) => type = args.type
		}],
		system: `Transform raw tickets into structured markdown following the template EXACTLY.

**MANDATORY STEPS:**
1. Identify ticket type: Bug, DevOps, Document, Enhancement, Refactor, or Security
2. Call \`type\` tool EXACTLY ONCE with the type from step 1
3. Call \`title\` tool EXACTLY ONCE in format: "[Module] - [Verb] [subject]" (example: Storage - fix file uploads)
4. Output formatted markdown matching template structure below

**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 changed
- Complexity: Technical difficulty
- Unknowns: Research/uncertainty needed

**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 search = await fetch(`${git}/api/v1/repos/issues/search`, {
		method: 'POST',
		headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
		body: JSON.stringify({
			priority_repo_id: repo,
			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(`${title}\n\`\`\`markdown\n${body}\n\`\`\``, {
		system: `Your job is to identify duplicates. Respond with the ID number of the duplicate or nothing if there are no matches \n\n${dupes}`
	}))?.pop()?.content;
	// Handle duplicates
	if(!!hasDuplicates && (dupeId = dupeIds.find(id => hasDuplicates.includes(id.toString()))) != null) {
		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":["Reviewed/Duplicate"]}'
		}).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
	const updateRes = 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()}`); });
	if(type) { // Label
		await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}/labels`, {
			method: 'POST',
			headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
			body: `{"labels":["Reviewed/${type[0].toUpperCase() + type.slice(1).toLowerCase()}"]}`
		}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
	}

	console.log(`Title: ${title}\nType: ${type}\nBody:\n${body}`);
})();