import { RemoteCompute } from "./RemoteCompute.svelte";
import type { Position3D } from "$lib/types/positionable.js";
import { generateName } from "$lib/utils/generateName.js";
import { positionManager } from "$lib/utils/positionManager.js";
import {
	rootGet,
	healthCheckHealthGet,
	listSessionsSessionsGet,
	createSessionSessionsPost,
	startInferenceSessionsSessionIdStartPost,
	stopInferenceSessionsSessionIdStopPost,
	deleteSessionSessionsSessionIdDelete
} from "@robothub/inference-server-client";
import { settings } from "$lib/runes/settings.svelte";
import type {
	CreateSessionRequest,
	CreateSessionResponse
} from "@robothub/inference-server-client";

export type ModelType = "act" | "diffusion" | "smolvla" | "pi0" | "groot" | "custom";

export interface ModelTypeConfig {
	id: ModelType;
	label: string;
	icon: string;
	description: string;
	defaultPolicyPath: string;
	defaultCameraNames: string[];
	requiresLanguageInstruction?: boolean;
	enabled: boolean;
}

export const MODEL_TYPES: Record<ModelType, ModelTypeConfig> = {
	act: {
		id: "act",
		label: "ACT Model",
		icon: "icon-[mdi--brain]",
		description: "Action Chunking with Transformers",
		defaultPolicyPath: "LaetusH/act_so101_beyond",
		defaultCameraNames: ["front"],
		enabled: true
	},
	diffusion: {
		id: "diffusion",
		label: "Diffusion Policy",
		icon: "icon-[mdi--creation]",
		description: "Diffusion-based robot control",
		defaultPolicyPath: "diffusion_policy/default",
		defaultCameraNames: ["front", "wrist"],
		enabled: true
	},
	smolvla: {
		id: "smolvla",
		label: "SmolVLA",
		icon: "icon-[mdi--eye-outline]",
		description: "Small Vision-Language-Action model",
		defaultPolicyPath: "smolvla/latest",
		defaultCameraNames: ["front"],
		requiresLanguageInstruction: true,
		enabled: true
	},
	pi0: {
		id: "pi0",
		label: "Pi0",
		icon: "icon-[mdi--pi]",
		description: "Lightweight robotics model",
		defaultPolicyPath: "pi0/base",
		defaultCameraNames: ["front"],
		enabled: true
	},
	groot: {
		id: "groot",
		label: "NVIDIA Groot",
		icon: "icon-[mdi--robot-outline]",
		description: "Humanoid robotics foundation model",
		defaultPolicyPath: "nvidia/groot",
		defaultCameraNames: ["front", "left", "right"],
		requiresLanguageInstruction: true,
		enabled: false // Not yet implemented
	},
	custom: {
		id: "custom",
		label: "Custom Model",
		icon: "icon-[mdi--cog]",
		description: "Custom model configuration",
		defaultPolicyPath: "",
		defaultCameraNames: ["front"],
		enabled: true
	}
};

export interface AISessionConfig {
	sessionId: string;
	modelType: ModelType;
	policyPath: string;
	cameraNames: string[];
	transportServerUrl: string;
	workspaceId?: string;
	languageInstruction?: string;
}

export interface AISessionResponse {
	workspace_id: string;
	camera_room_ids: Record<string, string>;
	joint_input_room_id: string;
	joint_output_room_id: string;
}

export interface AISessionStatus {
	session_id: string;
	status: "initializing" | "ready" | "running" | "stopped";
	policy_path: string;
	camera_names: string[];
	workspace_id: string;
	rooms: {
		workspace_id: string;
		camera_room_ids: Record<string, string>;
		joint_input_room_id: string;
		joint_output_room_id: string;
	};
	stats: {
		inference_count: number;
		commands_sent: number;
		joints_received: number;
		images_received: Record<string, number>;
		errors: number;
		actions_in_queue: number;
	};
	inference_stats?: {
		inference_count: number;
		total_inference_time: number;
		average_inference_time: number;
		average_fps: number;
		is_loaded: boolean;
		device: string;
	};
	error_message?: string;
}

export class RemoteComputeManager {
	private _computes = $state<RemoteCompute[]>([]);

	constructor() {
		// No client initialization needed anymore
	}

	// Reactive getters
	get computes(): RemoteCompute[] {
		return this._computes;
	}

	get computeCount(): number {
		return this._computes.length;
	}

	get runningComputes(): RemoteCompute[] {
		return this._computes.filter((compute) => compute.status === "running");
	}

	/**
	 * Get available model types
	 */
	get availableModelTypes(): ModelTypeConfig[] {
		return Object.values(MODEL_TYPES).filter((model) => model.enabled);
	}

	/**
	 * Get model type configuration
	 */
	getModelTypeConfig(modelType: ModelType): ModelTypeConfig | undefined {
		return MODEL_TYPES[modelType];
	}

	/**
	 * Create a new AI compute instance with full configuration
	 */
	async createComputeWithSession(
		config: AISessionConfig,
		computeId?: string,
		computeName?: string,
		position?: Position3D
	): Promise<{ success: boolean; error?: string; compute?: RemoteCompute }> {
		const finalComputeId = computeId || generateName();

		// Check if compute already exists
		if (this._computes.find((c) => c.id === finalComputeId)) {
			return { success: false, error: `Compute with ID ${finalComputeId} already exists` };
		}

		try {
			// Create compute instance
			const compute = new RemoteCompute(finalComputeId, computeName);
			compute.modelType = config.modelType;

			// Set position (from position manager if not provided)
			compute.position = position || positionManager.getNextPosition();

			// Add to reactive array
			this._computes.push(compute);

			// Create the session immediately
			const sessionResult = await this.createSession(compute.id, config);
			if (!sessionResult.success) {
				// Remove compute if session creation failed
				await this.removeCompute(compute.id);
				return { success: false, error: sessionResult.error };
			}

			console.log(
				`Created compute ${finalComputeId} with ${config.modelType} model at position (${compute.position.x.toFixed(1)}, ${compute.position.y.toFixed(1)}, ${compute.position.z.toFixed(1)}). Total computes: ${this._computes.length}`
			);

			return { success: true, compute };
		} catch (error) {
			console.error("Failed to create compute with session:", error);
			return {
				success: false,
				error: error instanceof Error ? error.message : String(error)
			};
		}
	}

	/**
	 * Create a new AI compute instance (legacy method)
	 */
	createCompute(id?: string, name?: string, position?: Position3D): RemoteCompute {
		const computeId = id || generateName();

		// Check if compute already exists
		if (this._computes.find((c) => c.id === computeId)) {
			throw new Error(`Compute with ID ${computeId} already exists`);
		}

		// Create compute instance
		const compute = new RemoteCompute(computeId, name);

		// Set position (from position manager if not provided)
		compute.position = position || positionManager.getNextPosition();

		// Add to reactive array
		this._computes.push(compute);

		console.log(
			`Created compute ${computeId} at position (${compute.position.x.toFixed(1)}, ${compute.position.y.toFixed(1)}, ${compute.position.z.toFixed(1)}). Total computes: ${this._computes.length}`
		);

		return compute;
	}

	/**
	 * Get compute by ID
	 */
	getCompute(id: string): RemoteCompute | undefined {
		return this._computes.find((c) => c.id === id);
	}

	/**
	 * Remove a compute instance
	 */
	async removeCompute(id: string): Promise<void> {
		const computeIndex = this._computes.findIndex((c) => c.id === id);
		if (computeIndex === -1) return;

		const compute = this._computes[computeIndex];

		// Clean up compute resources
		await this.stopSession(id);
		await this.deleteSession(id);

		// Remove from reactive array
		this._computes.splice(computeIndex, 1);

		console.log(`Removed compute ${id}. Remaining computes: ${this._computes.length}`);
	}

	/**
	 * Create an Inference Session
	 */
	async createSession(
		computeId: string,
		config: AISessionConfig
	): Promise<{ success: boolean; error?: string; data?: AISessionResponse }> {
		const compute = this.getCompute(computeId);
		if (!compute) {
			return { success: false, error: `Compute ${computeId} not found` };
		}

		try {
			const request: CreateSessionRequest = {
				session_id: config.sessionId,
				policy_path: config.policyPath,
				camera_names: config.cameraNames,
				transport_server_url: config.transportServerUrl,
				workspace_id: config.workspaceId || undefined,
				policy_type: config.modelType, // Use model type as policy type
				language_instruction: config.languageInstruction || undefined
			};

			const response = await createSessionSessionsPost({
				body: request,
				baseUrl: settings.inferenceServerUrl
			});

			if (!response.data) {
				throw new Error("Failed to create session - no data returned");
			}

			const data: CreateSessionResponse = response.data;

			// Update compute with session info
			compute.sessionId = config.sessionId;
			compute.status = "ready";
			compute.sessionConfig = config;
			compute.sessionData = {
				workspace_id: data.workspace_id,
				camera_room_ids: data.camera_room_ids,
				joint_input_room_id: data.joint_input_room_id,
				joint_output_room_id: data.joint_output_room_id
			};

			return { success: true, data: compute.sessionData };
		} catch (error) {
			console.error(`Failed to create session for compute ${computeId}:`, error);
			return {
				success: false,
				error: error instanceof Error ? error.message : String(error)
			};
		}
	}

	/**
	 * Start inference for a session
	 */
	async startSession(computeId: string): Promise<{ success: boolean; error?: string }> {
		const compute = this.getCompute(computeId);
		if (!compute || !compute.sessionId) {
			return { success: false, error: "No session to start" };
		}

		try {
			await startInferenceSessionsSessionIdStartPost({
				path: { session_id: compute.sessionId },
				baseUrl: settings.inferenceServerUrl
			});
			compute.status = "running";
			return { success: true };
		} catch (error) {
			console.error(`Failed to start session for compute ${computeId}:`, error);
			return {
				success: false,
				error: error instanceof Error ? error.message : String(error)
			};
		}
	}

	/**
	 * Stop inference for a session
	 */
	async stopSession(computeId: string): Promise<{ success: boolean; error?: string }> {
		const compute = this.getCompute(computeId);
		if (!compute || !compute.sessionId) {
			return { success: false, error: "No session to stop" };
		}

		try {
			await stopInferenceSessionsSessionIdStopPost({
				path: { session_id: compute.sessionId },
				baseUrl: settings.inferenceServerUrl
			});
			compute.status = "stopped";
			return { success: true };
		} catch (error) {
			console.error(`Failed to stop session for compute ${computeId}:`, error);
			return {
				success: false,
				error: error instanceof Error ? error.message : String(error)
			};
		}
	}

	/**
	 * Delete a session
	 */
	async deleteSession(computeId: string): Promise<{ success: boolean; error?: string }> {
		const compute = this.getCompute(computeId);
		if (!compute || !compute.sessionId) {
			return { success: true }; // Already deleted
		}

		try {
			await deleteSessionSessionsSessionIdDelete({
				path: { session_id: compute.sessionId },
				baseUrl: settings.inferenceServerUrl
			});

			// Reset compute session info
			compute.sessionId = null;
			compute.status = "disconnected";
			compute.sessionConfig = null;
			compute.sessionData = null;

			return { success: true };
		} catch (error) {
			console.error(`Failed to delete session for compute ${computeId}:`, error);
			return {
				success: false,
				error: error instanceof Error ? error.message : String(error)
			};
		}
	}

	/**
	 * Get session status
	 */
	async getSessionStatus(
		computeId: string
	): Promise<{ success: boolean; data?: AISessionStatus; error?: string }> {
		const compute = this.getCompute(computeId);
		if (!compute || !compute.sessionId) {
			return { success: false, error: "No session found" };
		}

		try {
			// Get all sessions and find the one we want
			const response = await listSessionsSessionsGet({
				baseUrl: settings.inferenceServerUrl
			});

			if (!response.data) {
				throw new Error("Failed to get sessions list");
			}

			const session = response.data.find((s) => s.session_id === compute.sessionId);
			if (!session) {
				throw new Error(`Session ${compute.sessionId} not found`);
			}

			// Update compute status
			compute.status = session.status as "initializing" | "ready" | "running" | "stopped";

			// Convert to AISessionStatus format
			const sessionStatus: AISessionStatus = {
				session_id: session.session_id,
				status: session.status as "initializing" | "ready" | "running" | "stopped",
				policy_path: session.policy_path,
				camera_names: session.camera_names,
				workspace_id: session.workspace_id,
				rooms: session.rooms as any,
				stats: session.stats as any,
				inference_stats: session.inference_stats as any,
				error_message: session.error_message || undefined
			};

			return { success: true, data: sessionStatus };
		} catch (error) {
			console.error(`Failed to get session status for compute ${computeId}:`, error);
			return {
				success: false,
				error: error instanceof Error ? error.message : String(error)
			};
		}
	}

	/**
	 * Check AI server health
	 */
	async checkServerHealth(): Promise<{ success: boolean; data?: any; error?: string }> {
		try {
			const healthResponse = await rootGet({
				baseUrl: settings.inferenceServerUrl
			});

			if (!healthResponse.data) {
				return { success: false, error: "Server is not healthy" };
			}

			// Get detailed health info
			const detailedHealthResponse = await healthCheckHealthGet({
				baseUrl: settings.inferenceServerUrl
			});

			return { success: true, data: detailedHealthResponse.data };
		} catch (error) {
			console.error("Failed to check AI server health:", error);
			return {
				success: false,
				error: error instanceof Error ? error.message : String(error)
			};
		}
	}

	/**
	 * Clean up all computes
	 */
	async destroy(): Promise<void> {
		const cleanupPromises = this._computes.map(async (compute) => {
			await this.stopSession(compute.id);
			await this.deleteSession(compute.id);
		});
		await Promise.allSettled(cleanupPromises);
		this._computes.length = 0;
	}
}

// Global compute manager instance
export const remoteComputeManager = new RemoteComputeManager();