import {
	INodeType,
	INodeTypeDescription,
	IPollFunctions,
	INodeExecutionData,
	NodeApiError,
	NodeOperationError,
} from 'n8n-workflow';

interface LibreBookingSession {
	sessionToken: string;
	userId: number;
	sessionExpires: string;
}

interface ReservationData {
	referenceNumber: string;
	startDate: string;
	endDate: string;
	title: string;
	resourceId: number;
	userId: number;
	description?: string;
	resourceName?: string;
	[key: string]: any;
}

interface WorkflowStaticData {
	seenIds?: string[];
	reservationHashes?: Record<string, string>;
	isFirstPoll?: boolean;
	lastPollTime?: string;
}

/**
 * Authentifizierung bei LibreBooking
 */
async function authenticateTrigger(
	pollFunctions: IPollFunctions,
	baseUrl: string,
	username: string,
	password: string,
): Promise<LibreBookingSession> {
	try {
		const response = await pollFunctions.helpers.httpRequest({
			method: 'POST',
			url: `${baseUrl}/Web/Services/index.php/Authentication/Authenticate`,
			headers: { 'Content-Type': 'application/json' },
			body: { username, password },
			json: true,
		});

		if (!response.isAuthenticated) {
			throw new NodeOperationError(
				pollFunctions.getNode(),
				'Authentifizierung fehlgeschlagen',
			);
		}

		return {
			sessionToken: response.sessionToken,
			userId: response.userId,
			sessionExpires: response.sessionExpires,
		};
	} catch (error: any) {
		throw new NodeApiError(pollFunctions.getNode(), error, {
			message: 'Authentifizierung fehlgeschlagen',
		});
	}
}

/**
 * Abmeldung
 */
async function signOutTrigger(
	pollFunctions: IPollFunctions,
	baseUrl: string,
	session: LibreBookingSession,
): Promise<void> {
	try {
		await pollFunctions.helpers.httpRequest({
			method: 'POST',
			url: `${baseUrl}/Web/Services/index.php/Authentication/SignOut`,
			headers: { 'Content-Type': 'application/json' },
			body: {
				userId: session.userId,
				sessionToken: session.sessionToken,
			},
			json: true,
		});
	} catch (error) {
		// Ignoriere SignOut-Fehler
	}
}

/**
 * Reservierungen abrufen
 */
async function getReservations(
	pollFunctions: IPollFunctions,
	baseUrl: string,
	session: LibreBookingSession,
	startDateTime: string,
	endDateTime: string,
	filters: any,
): Promise<ReservationData[]> {
	const qs: any = {
		startDateTime,
		endDateTime,
	};

	if (filters.resourceId) qs.resourceId = filters.resourceId;
	if (filters.scheduleId) qs.scheduleId = filters.scheduleId;
	if (filters.userId) qs.userId = filters.userId;

	const response = await pollFunctions.helpers.httpRequest({
		method: 'GET',
		url: `${baseUrl}/Web/Services/index.php/Reservations/`,
		headers: {
			'Content-Type': 'application/json',
			'X-Booked-SessionToken': session.sessionToken,
			'X-Booked-UserId': session.userId.toString(),
		},
		qs,
		json: true,
	});

	return response.reservations || [];
}

/**
 * Detaillierte Reservierungsdaten abrufen
 */
async function getReservationDetails(
	pollFunctions: IPollFunctions,
	baseUrl: string,
	session: LibreBookingSession,
	referenceNumber: string,
): Promise<any> {
	const response = await pollFunctions.helpers.httpRequest({
		method: 'GET',
		url: `${baseUrl}/Web/Services/index.php/Reservations/${referenceNumber}`,
		headers: {
			'Content-Type': 'application/json',
			'X-Booked-SessionToken': session.sessionToken,
			'X-Booked-UserId': session.userId.toString(),
		},
		json: true,
	});

	return response;
}

/**
 * Zeitfenster berechnen
 */
function getTimeWindow(timeWindow: string): { start: string; end: string } {
	const now = new Date();
	const start = now.toISOString();
	
	let endDate = new Date(now);
	switch (timeWindow) {
		case '7days':
			endDate.setDate(endDate.getDate() + 7);
			break;
		case '14days':
			endDate.setDate(endDate.getDate() + 14);
			break;
		case '30days':
			endDate.setDate(endDate.getDate() + 30);
			break;
		case '90days':
			endDate.setDate(endDate.getDate() + 90);
			break;
		default:
			endDate.setDate(endDate.getDate() + 14);
	}

	return {
		start,
		end: endDate.toISOString(),
	};
}

/**
 * Hash für Reservierung generieren (für Änderungserkennung)
 * Nur relevante Felder berücksichtigen, die Änderungen anzeigen
 */
function getReservationHash(reservation: ReservationData): string {
	const relevantData = {
		referenceNumber: reservation.referenceNumber,
		startDate: reservation.startDate,
		endDate: reservation.endDate,
		title: reservation.title || '',
		description: reservation.description || '',
		resourceId: reservation.resourceId,
		resourceName: reservation.resourceName || '',
		userId: reservation.userId,
		requiresApproval: reservation.requiresApproval,
		participants: reservation.participants || [],
		invitees: reservation.invitees || [],
	};
	return JSON.stringify(relevantData);
}

/**
 * LibreBooking Trigger Node
 * 
 * Überwacht neue und geänderte Reservierungen in LibreBooking.
 * 
 * WICHTIG: Beim ersten Poll werden nur die IDs/Hashes gespeichert,
 * aber keine Events getriggert. Dies verhindert, dass alle 
 * existierenden Reservierungen als "neu" getriggert werden.
 */
export class LibreBookingTrigger implements INodeType {
	description: INodeTypeDescription = {
		displayName: 'LibreBooking Trigger',
		name: 'libreBookingTrigger',
		icon: 'file:librebooking.svg',
		group: ['trigger'],
		version: 1,
		description: 'Wird bei neuen oder geänderten Reservierungen in LibreBooking ausgelöst',
		subtitle: '={{$parameter["event"]}}',
		defaults: {
			name: 'LibreBooking Trigger',
		},
		inputs: [],
		outputs: ['main'],
		credentials: [
			{
				name: 'libreBookingApi',
				required: true,
			},
		],
		polling: true,
		properties: [
			{
				displayName: 'Event',
				name: 'event',
				type: 'options',
				options: [
					{ 
						name: 'Neue Reservierung', 
						value: 'newReservation', 
						description: 'Wird bei neuen Reservierungen ausgelöst (nicht beim ersten Poll)' 
					},
					{ 
						name: 'Geänderte Reservierung', 
						value: 'updatedReservation', 
						description: 'Wird bei geänderten Reservierungen ausgelöst' 
					},
					{ 
						name: 'Alle Reservierungen', 
						value: 'allReservations', 
						description: 'Wird bei neuen und geänderten Reservierungen ausgelöst' 
					},
				],
				default: 'newReservation',
			},
			{
				displayName: 'Hinweis',
				name: 'notice',
				type: 'notice',
				default: '',
				displayOptions: {
					show: {
						event: ['newReservation', 'allReservations'],
					},
				},
				description: 'Beim ersten Poll werden existierende Reservierungen gespeichert, aber nicht getriggert. Nur nachfolgende neue Reservierungen lösen den Trigger aus.',
			},
			{
				displayName: 'Filter',
				name: 'filters',
				type: 'collection',
				placeholder: 'Filter hinzufügen',
				default: {},
				options: [
					{ displayName: 'Ressourcen-ID', name: 'resourceId', type: 'number', default: '' },
					{ displayName: 'Zeitplan-ID', name: 'scheduleId', type: 'number', default: '' },
					{ displayName: 'Benutzer-ID', name: 'userId', type: 'number', default: '' },
				],
			},
			{
				displayName: 'Zeitfenster',
				name: 'timeWindow',
				type: 'options',
				options: [
					{ name: 'Nächste 7 Tage', value: '7days' },
					{ name: 'Nächste 14 Tage', value: '14days' },
					{ name: 'Nächste 30 Tage', value: '30days' },
					{ name: 'Nächste 90 Tage', value: '90days' },
				],
				default: '14days',
			},
			{
				displayName: 'Optionen',
				name: 'options',
				type: 'collection',
				placeholder: 'Option hinzufügen',
				default: {},
				options: [
					{ 
						displayName: 'Detaillierte Daten Abrufen', 
						name: 'fetchDetails', 
						type: 'boolean', 
						default: false,
						description: 'Ruft vollständige Reservierungsdaten ab (zusätzliche API-Aufrufe)',
					},
					{
						displayName: 'Debug-Modus',
						name: 'debugMode',
						type: 'boolean',
						default: false,
						description: 'Gibt zusätzliche Debug-Informationen aus',
					},
				],
			},
		],
	};

	async poll(this: IPollFunctions): Promise<INodeExecutionData[][] | null> {
		const credentials = await this.getCredentials('libreBookingApi');
		const baseUrl = (credentials.url as string).replace(/\/$/, '');
		const username = credentials.username as string;
		const password = credentials.password as string;

		const event = this.getNodeParameter('event') as string;
		const filters = this.getNodeParameter('filters', {}) as any;
		const timeWindow = this.getNodeParameter('timeWindow', '14days') as string;
		const options = this.getNodeParameter('options', {}) as any;

		// Workflow Static Data für State-Management
		const webhookData = this.getWorkflowStaticData('node') as WorkflowStaticData;
		
		// Debug-Modus
		const debugMode = options.debugMode || false;

		let session: LibreBookingSession;
		try {
			session = await authenticateTrigger(this, baseUrl, username, password);
		} catch (error) {
			throw error;
		}

		try {
			const { start, end } = getTimeWindow(timeWindow);

			const reservations = await getReservations(
				this,
				baseUrl,
				session,
				start,
				end,
				filters,
			);

			const returnData: INodeExecutionData[] = [];

			// ==========================================
			// EVENT: Neue Reservierungen
			// ==========================================
			if (event === 'newReservation') {
				// Initialisiere seenIds beim ersten Poll
				if (!webhookData.seenIds) {
					webhookData.seenIds = [];
					webhookData.isFirstPoll = true;
				}

				const currentIds = reservations.map((r: ReservationData) => r.referenceNumber);

				// Beim ersten Poll: Nur IDs speichern, NICHT triggern
				if (webhookData.isFirstPoll) {
					webhookData.seenIds = currentIds;
					webhookData.isFirstPoll = false;
					webhookData.lastPollTime = new Date().toISOString();
					
					if (debugMode) {
						return [[{
							json: {
								_debug: true,
								_message: 'Erster Poll - IDs wurden gespeichert, keine Events getriggert',
								_savedIds: currentIds.length,
								_timestamp: webhookData.lastPollTime,
							},
						}]];
					}
					
					return null; // Nichts triggern beim ersten Poll
				}

				// Nur NEUE Reservierungen (die wir noch nicht gesehen haben)
				const newReservations = reservations.filter((r: ReservationData) => 
					!webhookData.seenIds!.includes(r.referenceNumber)
				);

				// Update seenIds mit allen aktuellen IDs
				webhookData.seenIds = currentIds;
				webhookData.lastPollTime = new Date().toISOString();

				if (newReservations.length === 0) {
					return null;
				}

				// Neue Reservierungen verarbeiten
				for (const reservation of newReservations) {
					let reservationData = reservation;

					if (options.fetchDetails) {
						try {
							reservationData = await getReservationDetails(
								this,
								baseUrl,
								session,
								reservation.referenceNumber,
							);
						} catch (error) {
							reservationData = reservation;
						}
					}

					returnData.push({
						json: {
							...reservationData,
							_eventType: 'new',
							_triggeredAt: new Date().toISOString(),
						},
					});
				}
			}

			// ==========================================
			// EVENT: Geänderte Reservierungen
			// ==========================================
			else if (event === 'updatedReservation') {
				// Initialisiere reservationHashes beim ersten Poll
				if (!webhookData.reservationHashes) {
					webhookData.reservationHashes = {};
					webhookData.isFirstPoll = true;
				}

				// Beim ersten Poll: Nur Hashes speichern, NICHT triggern
				if (webhookData.isFirstPoll) {
					for (const reservation of reservations) {
						webhookData.reservationHashes[reservation.referenceNumber] = getReservationHash(reservation);
					}
					webhookData.isFirstPoll = false;
					webhookData.lastPollTime = new Date().toISOString();
					
					if (debugMode) {
						return [[{
							json: {
								_debug: true,
								_message: 'Erster Poll - Hashes wurden gespeichert, keine Events getriggert',
								_savedHashes: Object.keys(webhookData.reservationHashes).length,
								_timestamp: webhookData.lastPollTime,
							},
						}]];
					}
					
					return null; // Nichts triggern beim ersten Poll
				}

				// Geänderte Reservierungen finden
				const updatedReservations: ReservationData[] = [];
				const newHashes: Record<string, string> = {};

				for (const reservation of reservations) {
					const currentHash = getReservationHash(reservation);
					const oldHash = webhookData.reservationHashes[reservation.referenceNumber];
					newHashes[reservation.referenceNumber] = currentHash;

					// Nur als "geändert" markieren, wenn:
					// 1. Wir die Reservierung schon kennen (nicht neu)
					// 2. Der Hash sich geändert hat
					if (oldHash && currentHash !== oldHash) {
						updatedReservations.push(reservation);
					}
				}

				// Update Hashes mit allen aktuellen Reservierungen
				webhookData.reservationHashes = newHashes;
				webhookData.lastPollTime = new Date().toISOString();

				if (updatedReservations.length === 0) {
					return null;
				}

				// Geänderte Reservierungen verarbeiten
				for (const reservation of updatedReservations) {
					let reservationData = reservation;

					if (options.fetchDetails) {
						try {
							reservationData = await getReservationDetails(
								this,
								baseUrl,
								session,
								reservation.referenceNumber,
							);
						} catch (error) {
							reservationData = reservation;
						}
					}

					returnData.push({
						json: {
							...reservationData,
							_eventType: 'updated',
							_triggeredAt: new Date().toISOString(),
						},
					});
				}
			}

			// ==========================================
			// EVENT: Alle Reservierungen (Neu + Geändert)
			// ==========================================
			else if (event === 'allReservations') {
				// Initialisiere beide Tracking-Strukturen beim ersten Poll
				if (!webhookData.seenIds || !webhookData.reservationHashes) {
					webhookData.seenIds = [];
					webhookData.reservationHashes = {};
					webhookData.isFirstPoll = true;
				}

				// Beim ersten Poll: IDs und Hashes speichern, NICHT triggern
				if (webhookData.isFirstPoll) {
					webhookData.seenIds = reservations.map((r: ReservationData) => r.referenceNumber);
					for (const reservation of reservations) {
						webhookData.reservationHashes[reservation.referenceNumber] = getReservationHash(reservation);
					}
					webhookData.isFirstPoll = false;
					webhookData.lastPollTime = new Date().toISOString();
					
					if (debugMode) {
						return [[{
							json: {
								_debug: true,
								_message: 'Erster Poll - IDs und Hashes wurden gespeichert, keine Events getriggert',
								_savedIds: webhookData.seenIds.length,
								_savedHashes: Object.keys(webhookData.reservationHashes).length,
								_timestamp: webhookData.lastPollTime,
							},
						}]];
					}
					
					return null;
				}

				const newHashes: Record<string, string> = {};
				const currentIds: string[] = [];

				for (const reservation of reservations) {
					const refNumber = reservation.referenceNumber;
					const currentHash = getReservationHash(reservation);
					
					currentIds.push(refNumber);
					newHashes[refNumber] = currentHash;

					const isNew = !webhookData.seenIds!.includes(refNumber);
					const oldHash = webhookData.reservationHashes![refNumber];
					const isUpdated = oldHash && currentHash !== oldHash;

					if (isNew || isUpdated) {
						let reservationData = reservation;

						if (options.fetchDetails) {
							try {
								reservationData = await getReservationDetails(
									this,
									baseUrl,
									session,
									refNumber,
								);
							} catch (error) {
								reservationData = reservation;
							}
						}

						returnData.push({
							json: {
								...reservationData,
								_eventType: isNew ? 'new' : 'updated',
								_triggeredAt: new Date().toISOString(),
							},
						});
					}
				}

				// Update State
				webhookData.seenIds = currentIds;
				webhookData.reservationHashes = newHashes;
				webhookData.lastPollTime = new Date().toISOString();
			}

			if (returnData.length === 0) {
				return null;
			}

			return [returnData];

		} finally {
			await signOutTrigger(this, baseUrl, session);
		}
	}
}