/**
 * Custom loader for running agent with multiple character sequences
 * and random color palette cycles for each agentic flow.
 */

import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";

// Define spinner frame sequences (inspired by Claude Code)
const SPINNER_SEQUENCES = {
	braille_spinner: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
	braille_swirl: ["⢹", "⢺", "⢼", "⣸", "⣇", "⡧", "⡗", "⡏"],
	braille_dense: ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"],
	spark_quad: ["✢", "✣", "✤", "✥"],
	twinkle_cycle: ["⋆", "✦", "✧", "✶", "✷"],
	star_bloom: ["✺", "✹", "✸", "✷"],
	solar_flare: ["✴", "✷", "✶", "✸"],
	stellar_shift: ["✫", "✬", "✭", "✮"],
	glyph_spark: ["⁕", "⁑", "∗", "⋆"],
	dot_progress: [".", "..", "..."],
	binary_pulse: ["●", "○", "●", "○"],
	moon_phase: ["◐", "◓", "◑", "◒"],
	quarter_spin: ["◴", "◷", "◶", "◵"],
	pixel_blink: ["▪", "▫", "▪", "▫"],
	bar_wave: [ "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█", "▇", "▆", "▅", "▄", "▃", "▂", ],
	classic_spin: ["|", "/", "-", "\\"],
	line_orbit: ["╱", "─", "╲", "│"],
	box_rotation: ["┤", "┘", "┴", "└", "├", "┌", "┬", "┐"],
	arrow_compass: ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
	shade_pulse: ["░", "▒", "▓", "█", "▓", "▒"],
	corner_flip: ["▖", "▘", "▝", "▗"],
	block_flip: ["▌", "▀", "▐", "▄"],
	meter_sweep: [ "▉", "▊", "▋", "▌", "▍", "▎", "▏", "▎", "▍", "▌", "▋", "▊", "▉", ],
	descending_bars: [ "█", "▇", "▆", "▅", "▄", "▃", "▂", "▁", "▂", "▃", "▄", "▅", "▆", "▇", ],
	arc_bounce: ["⊶", "⊷"],
	corner_orbit: ["◜", "◝", "◞", "◟"],
	wave_smile: ["◡", "◠", "◡", "◠"],
	neural_ring: ["⊹", "⊱", "⋆", "⊰"],
	triangle_flow: ["⊰", "⊱", "⊲", "⊳"],
	signal_wave: ["∿", "≋", "∿", "≋"],
	audio_ramp: ["▁", "▂", "▃", "▄", "▅", "▄", "▃", "▂"],
	pulse_line: ["⌇", "⌁", "⌇", "⌁"],
	diagonal_flow: ["⋰", "⋱", "⋰", "⋱"],
	static_noise: ["≀", "≋", "≀", "≋"],
	thinking_paths: ["⋮", "⋰", "⋱", "⋮"],
	ai_blink: ["⟡", "⟢", "⟣", "⟡"],
	focus_ring: ["◌", "◎", "◉", "●", "◉", "◎"],
	minimal_pulse: ["·", "•", "∙", "•"],
	orbitals: ["∘", "⊚", "⊛", "⊜"],
	matrix_cross: ["╳", "╲", "╱", "╳"],
	cyber_fade: ["▓", "▒", "░", "▒"],
	hex_blink: ["⌬", "⌭", "⌬", "⌭"],
	diamond_shift: ["⧈", "⧉", "⧊", "⧋"],
	gem_cycle: ["⋄", "◇", "◆", "◈"],
	ancient_spin: ["𐄁", "𐄂", "𐄃", "𐄂"],
	orbital_focus: ["⊙", "⊚", "⊛", "⊚"],
	soft_rotation: ["◠", "◝", "◞", "◡"],
	future_arc: ["⟜", "⟝", "⟞", "⟟"],
	chrono_tick: ["⧖", "⧗", "⧖", "⧗"],
	vector_flow: ["⊸", "⟜", "⟝", "⟞"],
	soft_pulse: ["·", "•", "●", "•"],
	expanding_bloom: ["˖", "✦", "✧", "✦"],
	neural_activity: ["⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"],
	rotating_star: ["✶", "✸", "✹", "✺", "✹", "✷"],
	scanning_beam: [ "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█", "▉", "▊", "▋", "▌", "▍", "▎", ],
};

// Spinner verb variations (inspired by Claude Code)
const SPINNER_VERBS = [
	"Thinking",
	"Reasoning",
	"Cogitating",
	"Pondering",
	"Ruminating",
	"Contemplating",
	"Musing",
	"Brainstorming",
	"Ideating",
	"Dreaming",
	"Wondering",
	"Scheming",
	"Plotting",
	"Conjuring",
	"Whispering to the Machine",
	"Summoning Thoughts",
	"Consulting the Void",
	"Tickling the Neurons",
	"Shuffling Synapses",
	"Juggling Concepts",
	"Massaging Context",
	"Petting the Tokens",
	"Polishing Ideas",
	"Spinning Thoughts",
	"Untangling Threads",
	"Connecting Dots",
	"Weaving Logic",
	"Brewing Answers",
	"Cooking Up Something",
	"Simmering Ideas",
	"Fermenting Thoughts",
	"Distilling Knowledge",
	"Refining Signals",
	"Mining Patterns",
	"Excavating Context",
	"Digging Through Memory",
	"Searching the Archives",
	"Dusting Off Neurons",
	"Poking Around",
	"Peeking Into Possibilities",
	"Exploring Timelines",
	"Navigating the Thoughtspace",
	"Drifting Through Context",
	"Wandering the Datasphere",
	"Meandering Through Meanings",
	"Orbiting Ideas",
	"Threadweaving",
	"Mindmapping",
	"Thoughtcrafting",
	"Ideaweaving",
	"Logicrafting",
	"Queryweaving",
	"Contextspinning",
	"Synthespinning",
	"Datamancing",
	"Promptcrafting",
	"Semanticizing",
	"Heuristicating",
	"Inferencing",
	"Hyperthinking",
	"Metareasoning",
	"Sensemaking",
	"Possibility-Mapping",
	"Futurecasting",
	"Worldbuilding",
	"Chainweaving",
	"Neuralizing",
	"Token Dancing",
	"Vector Surfing",
	"Embedding Thoughts",
	"Routing Attention",
	"Traversing Latent Space",
	"Aligning Vibes",
	"Calibrating Brainwaves",
	"Synchronizing Thoughts",
	"Harmonizing Concepts",
	"Bending Probability",
	"Negotiating with Entropy",
	"Consulting Ancient Weights",
	"Awakening Parameters",
	"Petting the GPUs",
	"Cooling the Circuits",
	"Warming Up the Tokens",
	"Stretching the Context Window",
	"Recursing Recursively",
	"Thinking About Thinking",
	"Hallucinating Responsibly",
	"Untying Semantic Knots",
	"Unfolding Possibilities",
	"Herding Electrons",
	"Chasing Signals",
	"Following Breadcrumbs",
	"Vibecoding Internally",
	"Plausibility Checking",
	"Crossing Wires",
	"Aligning the Stars",
	"Consulting the Orb",
	"Reading the Tea Leaves",
	"Rolling for Insight",
	"Casting Logic Missiles",
	"Charging the Braincell",
	"Spinning Up Brainworms",
	"Waking the Gremlins",
	"Negotiating with Goblins",
	"Downloading Thoughts",
	"Defragmenting Consciousness",
	"Overclocking Imagination",
	"Reticulating Splines",
	"Grepping Reality",
	"Compiling Ideas",
	"Linking Concepts",
	"Escaping the Stack Trace",
	"Refactoring Thoughts",
	"Optimizing Brainpaths",
	"Allocating More Thinking",
	"Pinging the Collective Mind",
	"Loading Fun Subroutines",
	"Traversing the Idea Maze",
	"Tick-Tocking the Clockwork",
	"Untyping the Types",
	"Jittering Through Possibility Space",
	"Shapecasting Meaning",
	"Wrangling Semantics",
	"Vibesynthesizing",
	"Probabilitymaxxing",
	"Looptimizing",
	"Brainbuffering",
	"Thoughtpilling",
	"Contextmaxxing",
	"Mindspelunking",
	"Cognipuzzling",
	"Noodling",
	"Doodling with Logic",
	"Philosophizing",
	"Wizardposting",
	"Technomancing",
	"Arcane Computing",
	"Mystifying the Mainframe",
	"Consulting the Bit Spirits",
	"Asking the Ether",
	"Communing with Packets",
	"Wiggling Through Dimensions",
	"Performing Cognitive Acrobatics",
	"Doing Tiny Backflips Internally",
	"Spinning Plates of Thought",
	"Mentally Juggling Chainsaws",
	"Inventing New Problems",
	"Almost There",
	"Probably Thinking",
	"Definitely Not Panicking",
	"Making Educated Guesses",
	"Pretending to Be Organized",
	"Rearranging Mental Furniture",
	"Shaking the Thought Box",
	"Gently Stirring the Universe",
	"Consulting Several Braincells",
	"Borrowing Extra Intelligence",
	"Reaching Peak Noodle",
	"Experiencing Temporary Genius",
	"Manifesting an Answer",
	"Loading Cleverness",
	"Charging Wit Capacitors",
	"Generating Shenanigans",
	"Committing Acts of Computation",
	"Engaging Maximum Tomfoolery",
	"Doing Mysterious AI Things",
	"Frolicing",
];

// Generate a random palette with given amplitude rules
// Generate a random color palette with amplitude rules:
// - Hue: base random ±7.5° (total 15° range)
// - Saturation: base random 30-70% ±random 30-60%
// - Lightness: base random 40-80% ±random 30-60%
   function generateRandomPaletteColors(): number[] {
     const steps = 8;
		 const colorsHSL: [number, number, number][] = [];
		 
     // Random base HSL values
     const baseHue = randomFloat(0, 360);
     const baseSat = randomFloat(30, 70); // 30-70% saturation minimum
     const baseLight = randomFloat(30, 70); // 30-70% lightness minimum

     // Amplitudes with reduced variation ranges
     const hueAmp = 7.5; // ±7.5° total 15° range
     const satAmp = randomFloat(10, 20); // ±10-20% variation
     const lightAmp = randomFloat(10, 20); // ±10-20% variation

     // Helper to clamp values
     const clampHue = (h: number): number => ((h % 360) + 360) % 360;
     const clampPercent = (p: number): number => Math.max(0, Math.min(100, p));

     // Generate colors with HSL safety
     for (let i = 0; i < steps; i++) {
       // Generate color within safe ranges
       const hue = clampHue(baseHue + randomFloat(-hueAmp, hueAmp));
       const sat = clampPercent(baseSat + randomFloat(-satAmp, satAmp));
       const light = clampPercent(baseLight + randomFloat(-lightAmp, lightAmp));

       colorsHSL.push([hue, sat, light]);
     }

     // Sort colors by their HSL distance from base point
     colorsHSL.sort((a, b) => {
       // Calculate HSL components
       const [h1, s1, l1] = a;
       const [h2, s2, l2] = b;

       // Calculate Euclidean distance (simplified HSL space approximation)
       const dist1 = Math.sqrt(
         Math.pow(clampHue(h1 - baseHue), 2) +
         Math.pow(s1 - baseSat, 2) +
         Math.pow(l1 - baseLight, 2)
       );

       const dist2 = Math.sqrt(
         Math.pow(clampHue(h2 - baseHue), 2) +
         Math.pow(s2 - baseSat, 2) +
         Math.pow(l2 - baseLight, 2)
       );

       return dist1 - dist2;
     });

     return colorsHSL.map(([h, s, l]) => hslToAnsi(h,s,l));
   }
// Helper to apply ANSI color to a string
const colorize = (str: string, colorCode: number) =>
	`\x1b[38;5;${colorCode}m${str}\x1b[0m`;

// Random choice from array
function randomChoice<T>(arr: T[]): T {
	return arr[Math.floor(Math.random() * arr.length)];
}

// Random integer between min and max inclusive
function randomInt(min: number, max: number): number {
	return Math.floor(Math.random() * (max - min + 1)) + min;
}

// Random float between min (inclusive) and max (exclusive)
function randomFloat(min: number, max: number): number {
	return Math.random() * (max - min) + min;
}

// HSL to RGB conversion (h in [0,360), s,l in [0,100])
function hslToRgb(h: number, s: number, l: number): [number, number, number] {
	h /= 360;
	s /= 100;
	l /= 100;
	const a = s * Math.min(l, 1 - l);
	const f = (n: number) => {
		const k = (n + h * 12) % 12;
		return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
	};
	return [
		Math.round(f(0) * 255),
		Math.round(f(8) * 255),
		Math.round(f(4) * 255),
	];
}

// RGB to ANSI 256 color index (6x6x6 cube)
function rgbToAnsi256(r: number, g: number, b: number): number {
	if (r === g && g === b && r < 8) return 16; // black
	if (r === g && g === b && r > 248) return 231; // white
	// scale to 0-5
	const r5 = Math.round(r / 51);
	const g5 = Math.round(g / 51);
	const b5 = Math.round(b / 51);
	return 16 + 36 * r5 + 6 * g5 + b5;
}

// HSL to ANSI 256
function hslToAnsi(h: number, s: number, l: number): number {
	const [r, g, b] = hslToRgb(h, s, l);
	return rgbToAnsi256(r, g, b);
}

// Generate colored frames from a sequence and palette
function generateColoredFrames(
	sequence: string[],
	palette: number[],
): string[] {
	return sequence.map((frame, idx) => {
		const color = palette[idx % palette.length];
		return colorize(frame, color);
	});
}

// Current loader state
let currentSequenceName: string | null = null;

let currentIntervalMs: number = 80;

export default function (pi: ExtensionAPI) {
	pi.on("agent_start", async (_event, ctx) => {
		if (!ctx.hasUI) return;

		// Randomly select a sequence, palette, and interval
		const sequenceName = randomChoice(Object.keys(SPINNER_SEQUENCES));
		const sequence =
			SPINNER_SEQUENCES[sequenceName as keyof typeof SPINNER_SEQUENCES];
		const palette = generateRandomPaletteColors();
		const intervalMs = randomInt(100, 200);

		currentSequenceName = sequenceName;

		currentIntervalMs = intervalMs;

		const coloredFrames = generateColoredFrames(sequence, palette);

		// Set the working indicator with custom frames
		ctx.ui.setWorkingIndicator({
			frames: coloredFrames,
			intervalMs,
		});

		// Set initial message
		ctx.ui.setWorkingMessage(`${randomChoice(SPINNER_VERBS)}...`);
	});

	pi.on("agent_end", (_event, ctx) => {
		if (!ctx.hasUI) return;
		// Restore default indicator
		ctx.ui.setWorkingIndicator();
		ctx.ui.setWorkingMessage();
		currentSequenceName = null;
	});

	pi.on("tool_call", async (event, ctx) => {
		if (!ctx.hasUI) return;
		// Update message with current tool
		ctx.ui.setWorkingMessage(`Running ${event.toolName}...`);
	});

	pi.on("tool_result", (_event, ctx) => {
		if (!ctx.hasUI) return;
		// Update message back to generic
		ctx.ui.setWorkingMessage(`${randomChoice(SPINNER_VERBS)}...`);
	});

	// Optionally register a command to show current loader info
	pi.registerCommand("loader-info", {
		description: "Show current loader sequence",
		handler: async (_args, ctx) => {
			if (currentSequenceName) {
				ctx.ui.notify(
					`Current loader: ${currentSequenceName}, interval ${currentIntervalMs}ms`,
					"info",
				);
			} else {
				ctx.ui.notify("No active agent loader.", "info");
			}
		},
	});

	// Command to manually trigger a new random loader
	pi.registerCommand("loader-random", {
		description: "Randomize the loader for the current agent flow",
		handler: async (_args, ctx) => {
			if (!ctx.hasUI) return;
			// Simulate agent_start logic
			const sequenceName = randomChoice(Object.keys(SPINNER_SEQUENCES));
			const sequence =
				SPINNER_SEQUENCES[sequenceName as keyof typeof SPINNER_SEQUENCES];
			const palette = generateRandomPaletteColors();
			const intervalMs = randomInt(90, 150);

			currentSequenceName = sequenceName;
			currentIntervalMs = intervalMs;

			const coloredFrames = generateColoredFrames(sequence, palette);
			ctx.ui.setWorkingIndicator({ frames: coloredFrames, intervalMs });
			ctx.ui.setWorkingMessage(`${randomChoice(SPINNER_VERBS)}...`);
			ctx.ui.notify(`Loader changed to ${sequenceName}`, "info");
		},
	});

	// Command to preview all available loaders
	pi.registerCommand("loader-preview", {
		description: "Preview all available loader sequences and palettes",
		handler: async (_args, ctx) => {
			if (!ctx.hasUI) return;

			const sequenceNames = Object.keys(SPINNER_SEQUENCES);
			let preview = "Available sequences:\n";
			for (const name of sequenceNames) {
				const seq = SPINNER_SEQUENCES[name as keyof typeof SPINNER_SEQUENCES];
				preview += `  ${name}: ${seq[0]} ${seq.length} frames\n`;
			}

			preview += "\nSample random palettes (regenerated each time):\n";
			for (let i = 1; i <= 3; i++) {
				const palette = generateRandomPaletteColors();
				// Show color blocks
				const blocks = palette
					.slice(0, 4)
					.map((c) => colorize("■", c))
					.join("");
				preview += `  Random ${i}: ${blocks} (${palette.length} colors)\n`;
			}

			ctx.ui.notify(preview, "info");
		},
	});

	// Command to pick a specific loader
	pi.registerCommand("loader-pick", {
		description: "Pick a specific loader sequence and palette",
		handler: async (_args, ctx) => {
			if (!ctx.hasUI) return;

			// Choose sequence
			const sequenceNames = Object.keys(SPINNER_SEQUENCES);
			const chosenSequence = await ctx.ui.select(
				"Choose spinner sequence:",
				sequenceNames,
			);
			if (!chosenSequence) return;

			// Choose interval (optional)
			const intervalOptions = ["60ms", "80ms", "100ms", "120ms", "Random"];
			const chosenInterval = await ctx.ui.select(
				"Choose animation interval:",
				intervalOptions,
			);
			if (!chosenInterval) return;

			const intervalMs =
				chosenInterval === "Random"
					? randomInt(90, 150)
					: parseInt(chosenInterval);

			// Apply
			const sequence =
				SPINNER_SEQUENCES[chosenSequence as keyof typeof SPINNER_SEQUENCES];
			const palette = generateRandomPaletteColors();
			const coloredFrames = generateColoredFrames(sequence, palette);

			currentSequenceName = chosenSequence;
			currentIntervalMs = intervalMs;

			ctx.ui.setWorkingIndicator({ frames: coloredFrames, intervalMs });
			ctx.ui.setWorkingMessage(`${randomChoice(SPINNER_VERBS)}...`);
			ctx.ui.notify(`Loader set to ${chosenSequence}`, "info");
		},
	});
}