/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: BUSL-1.1
 */
import { StormEventFileDone, StormEventPage, StormImage } from './events';
import { filesystemManager } from '../filesystemManager';

import { Response } from 'express';
import os from 'node:os';
import Path from 'path';
import FS from 'fs-extra';
import FSExtra from 'fs-extra';
import { ConversationItem } from './stream';
import exp from 'node:constants';
import { ImagePrompt } from './PageGenerator';
import clusterConfiguration from '@kapeta/local-cluster-config';

export const SystemIdHeader = 'System-Id';

export function normalizePath(path: string) {
    return path
        .replace(/#.*$/g, '') // Remove hash
        .replace(/\?.*$/gi, '') // Remove query params
        .replace(/:[a-z][a-z_]*\b/gi, '*') // Replace all params with *
        .replace(/\{[a-z-.]+}/gi, '*'); // Replace all variables with *
}

export async function writePageToDisk(systemId: string, event: StormEventPage) {
    const baseDir = getSystemBaseDir(systemId);
    const filePath = getFilePath(event.payload.method);
    const path = Path.join(baseDir, normalizePath(event.payload.path), filePath);
    await FS.ensureDir(Path.dirname(path));
    await FS.writeFile(path, event.payload.content);

    console.log(`Page written to disk: ${event.payload.title} > ${path}`);

    return {
        path,
    };
}

export async function writeAssetToDisk(systemId: string, event: StormEventFileDone) {
    const baseDir = getSystemBaseDir(systemId);
    const path = Path.join(baseDir, 'public', event.payload.filename);
    await FS.ensureDir(Path.dirname(path));
    await FS.writeFile(path, event.payload.content);

    return {
        path,
    };
}

export async function writeImageToDisk(systemId: string, event: StormImage, prompt: ImagePrompt) {
    const baseDir = getSystemBaseDir(systemId);
    const path = Path.join(baseDir, normalizePath(prompt.url));

    const response = await fetch(event.payload.href);
    if (!response.ok || !response.body) {
        throw new Error(`Failed to fetch image: ${event.payload.href}`);
    }

    await FS.ensureDir(Path.dirname(path));

    const buffer = await response.arrayBuffer();
    await FS.writeFile(path, Buffer.from(buffer));

    console.log(`Image written to disk: ${event.payload.href} > ${path}`);

    return {
        path,
    };
}

export function hasPageOnDisk(systemId: string, path: string, method: string) {
    const fullPath = resolveReadPath(systemId, path, method);
    console.log('Checking for page on disk:', fullPath);
    return !!fullPath && FS.existsSync(fullPath);
}

export function getSystemBaseDir(systemId: string) {
    return Path.join(filesystemManager.getProjectRootFolder() || os.tmpdir(), 'ai-systems', systemId);
}

export function getSystemBaseImplDir(systemId: string) {
    return Path.join(os.tmpdir(), 'ai-systems-impl', systemId);
}

function getFilePath(method: string) {
    // For HEAD requests, we assume we're serving looking for a GET resource
    return Path.join(method === 'HEAD' ? 'get' : method.toLowerCase(), 'index.html');
}

export function resolveReadPath(systemId: string, path: string, method: string) {
    const baseDir = getSystemBaseDir(systemId);

    path = normalizePath(path);

    let fullPath = Path.join(baseDir, path);

    //First check if there is a file at the exact path
    try {
        const stat = FS.statSync(fullPath);
        if (stat && stat.isFile()) {
            return fullPath;
        }
    } catch (e) {
        // Ignore
    }

    const filePath = getFilePath(method);
    fullPath = Path.join(baseDir, path, filePath);

    if (FS.existsSync(fullPath)) {
        return fullPath;
    }

    const parts = path.split('/');

    let currentPath = '';

    for (let part of parts) {
        const thisPath = Path.join(currentPath, part);
        const starPath = Path.join(currentPath, '*');
        const thisPathDir = Path.join(baseDir, thisPath);
        const starPathDir = Path.join(baseDir, starPath);

        if (FS.existsSync(thisPathDir)) {
            currentPath = thisPath;
            continue;
        }

        if (FS.existsSync(starPathDir)) {
            currentPath = starPath;
            continue;
        }

        // Path not found
        return null;
    }

    return Path.join(baseDir, currentPath, filePath);
}

export function readPageFromDiskAsString(systemId: string, path: string, method: string) {
    const filePath = resolveReadPath(systemId, path, method);
    if (!filePath || !FS.existsSync(filePath)) {
        return null;
    }

    return FS.readFileSync(filePath, 'utf8');
}

export function readPageFromDisk(systemId: string, path: string, method: string, res: Response) {
    const filePath = resolveReadPath(systemId, path, method);
    if (!filePath || !FS.existsSync(filePath)) {
        if (method === 'HEAD') {
            // For HEAD requests, only return the status and headers
            res.status(202).set('Retry-After', '3').end();
        } else {
            // For GET requests, return the fallback HTML with status 202
            res.status(202).set('Retry-After', '3').send(getFallbackHtml(path, method));
        }
        return;
    }

    res.type(filePath.split('.').pop() as string);

    const content = FS.readFileSync(filePath);

    if (method === 'HEAD') {
        // For HEAD requests, just end the response after setting headers
        res.status(200).end();
    } else {
        // For GET requests, return the full content
        res.write(content);
        res.end();
    }
}

function getFallbackHtml(path: string, method: string): string {
    return `
        <!DOCTYPE html>
        <html lang="en">

        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Page Not Ready</title>
            <style>
                @import url('https://fonts.googleapis.com/css2?family=Roboto:wght@400;600&display=swap');

                body {
                    margin: 0;
                    padding: 0;
                    display: flex;
                    align-items: center;
                    justify-content: center;
                    height: 100vh;
                    font-family: 'Roboto', sans-serif;
                    background: #1E1F20;
                    color: white;
                    text-align: center;
                }

                h1 {
                    font-size: 2rem;
                    font-weight: 600;
                    margin-bottom: 1rem;
                }

                p {
                    font-size: 1rem;
                    font-weight: 400;
                }
            </style>
        </head>

        <body>
            <div>
                <h1>Page Not Ready</h1>
                <p>Henrik is still working on this page. Please wait...</p>
            </div>
            <script>
                const checkInterval = 3000;
                function checkPageReady() {
                    fetch('/${path}', { method: 'HEAD' })
                        .then(response => {
                            if (response.status === 200) {
                                // The page is ready, reload to fetch it
                                window.location.reload(); 
                            } else if (response.status === 202) {
                                const retryAfter = response.headers.get('Retry-After');
                                const retryInterval = retryAfter ? parseInt(retryAfter) * 1000 : 3000;
                                setTimeout(checkPageReady, retryInterval);
                            } else {
                                // Handle other unexpected statuses
                                setTimeout(checkPageReady, 3000);
                            }
                        })
                        .catch(error => {
                            console.error('Error checking page status:', error);
                            setTimeout(checkPageReady, checkInterval);
                        });
                }
                setTimeout(checkPageReady, checkInterval); 
            </script>
        </body>

        </html>        
    `;
}

export interface Conversation {
    messages: ConversationItem[];
    variantId: string;
    type: 'page';
    filename: string;
}

export function readConversationFromFile(filename: string): Conversation[] {
    if (!FS.existsSync(filename)) {
        return [];
    }
    const content = FS.readFileSync(filename).toString();
    if (!content.trim()) {
        return [];
    }
    return content.split(/\n/g).map((line) => JSON.parse(line) as Conversation);
}

export function writeConversationToFile(filename: string, conversations: Conversation[]) {
    FS.writeFileSync(filename, conversations.map((conversation) => JSON.stringify(conversation)).join('\n'));
}