import { BarModule, NotificationAnchor, PositionAnchor } from './types/options';
import { OSDAnchor } from './types/options';
import icons, { substitutes } from './icons/icons';
import GLib from 'gi://GLib?version=2.0';
import GdkPixbuf from 'gi://GdkPixbuf';
import { NotificationArgs } from './types/notification';
import { namedColors } from './constants/colors';
import { distroIcons } from './constants/distro';
import { distro } from './variables';
import options from '../options';
import { Astal, Gdk, Gtk } from 'astal/gtk3';
import AstalApps from 'gi://AstalApps?version=0.1';
import { exec, execAsync } from 'astal/process';

/**
 * Handles errors by throwing a new Error with a message.
 *
 * This function takes an error object and throws a new Error with the provided message or a default message.
 * If the error is an instance of Error, it uses the error's message. Otherwise, it converts the error to a string.
 *
 * @param error The error to handle.
 *
 * @throws Throws a new error with the provided message or a default message.
 */
export function errorHandler(error: unknown): never {
    if (error instanceof Error) {
        throw new Error(error.message);
    }

    throw new Error(String(error));
}

/**
 * Looks up an icon by name and size.
 *
 * This function retrieves an icon from the default icon theme based on the provided name and size.
 * If the name is not provided, it returns null.
 *
 * @param name The name of the icon to look up.
 * @param size The size of the icon to look up. Defaults to 16.
 *
 * @returns The Gtk.IconInfo object if the icon is found, or null if not found.
 */
export function lookUpIcon(name?: string, size = 16): Gtk.IconInfo | null {
    if (!name) return null;

    return Gtk.IconTheme.get_default().lookup_icon(name, size, Gtk.IconLookupFlags.USE_BUILTIN);
}

/**
 * Retrieves all unique layout items from the bar options.
 *
 * This function extracts all unique layout items from the bar options defined in the `options` object.
 * It iterates through the layouts for each monitor and collects items from the left, middle, and right sections.
 *
 * @returns An array of unique layout items.
 */
export function getLayoutItems(): BarModule[] {
    const { layouts } = options.bar;

    const itemsInLayout: BarModule[] = [];

    Object.keys(layouts.get()).forEach((monitor) => {
        const leftItems = layouts.get()[monitor].left;
        const rightItems = layouts.get()[monitor].right;
        const middleItems = layouts.get()[monitor].middle;

        itemsInLayout.push(...leftItems);
        itemsInLayout.push(...middleItems);
        itemsInLayout.push(...rightItems);
    });

    return [...new Set(itemsInLayout)];
}

/**
 * Retrieves the appropriate icon based on the provided name and fallback.
 *
 * This function returns a substitute icon if available, the original name if it exists as a file, or a fallback icon.
 * It also logs a message if no substitute icon is found.
 *
 * @param name The name of the icon to look up.
 * @param fallback The fallback icon to use if the name is not found. Defaults to `icons.missing`.
 *
 * @returns The icon name or the fallback icon.
 */
export function icon(name: string | null, fallback = icons.missing): string {
    const validateSubstitute = (name: string): name is keyof typeof substitutes => name in substitutes;

    if (!name) return fallback || '';

    if (GLib.file_test(name, GLib.FileTest.EXISTS)) return name;

    let icon: string = name;

    if (validateSubstitute(name)) {
        icon = substitutes[name];
    }

    if (lookUpIcon(icon)) return icon;

    console.log(`no icon substitute "${icon}" for "${name}", fallback: "${fallback}"`);
    return fallback;
}

/**
 * Executes a bash command asynchronously.
 *
 * This function runs a bash command using `execAsync` and returns the output as a string.
 * It handles errors by logging them and returning an empty string.
 *
 * @param strings The command to execute as a template string or a regular string.
 * @param values Additional values to interpolate into the command.
 *
 * @returns A promise that resolves to the command output as a string.
 */
export async function bash(strings: TemplateStringsArray | string, ...values: unknown[]): Promise<string> {
    const cmd =
        typeof strings === 'string' ? strings : strings.flatMap((str, i) => str + `${values[i] ?? ''}`).join('');

    return execAsync(['bash', '-c', cmd]).catch((err) => {
        console.error(cmd, err);
        return '';
    });
}

/**
 * Executes a shell command asynchronously.
 *
 * This function runs a shell command using `execAsync` and returns the output as a string.
 * It handles errors by logging them and returning an empty string.
 *
 * @param cmd The command to execute as a string or an array of strings.
 *
 * @returns A promise that resolves to the command output as a string.
 */
export async function sh(cmd: string | string[]): Promise<string> {
    return execAsync(cmd).catch((err) => {
        console.error(typeof cmd === 'string' ? cmd : cmd.join(' '), err);
        return '';
    });
}

/**
 * Generates an array of JSX elements for each monitor.
 *
 * This function creates an array of JSX elements by calling the provided widget function for each monitor.
 * It uses the number of monitors available in the default Gdk display.
 *
 * @param widget A function that takes a monitor index and returns a JSX element.
 *
 * @returns An array of JSX elements, one for each monitor.
 */
export function forMonitors(widget: (monitor: number) => JSX.Element): JSX.Element[] {
    const n = Gdk.Display.get_default()?.get_n_monitors() || 1;
    return range(n, 0).flatMap(widget);
}

/**
 * Generates an array of numbers within a specified range.
 *
 * This function creates an array of numbers starting from the `start` value up to the specified `length`.
 *
 * @param length The length of the array to generate.
 * @param start The starting value of the range. Defaults to 1.
 *
 * @returns An array of numbers within the specified range.
 */
export function range(length: number, start = 1): number[] {
    return Array.from({ length }, (_, i) => i + start);
}

/**
 * Checks if all specified dependencies are available.
 *
 * This function verifies the presence of the specified binaries using the `which` command.
 * It logs a warning and sends a notification if any dependencies are missing.
 *
 * @param bins The list of binaries to check.
 *
 * @returns True if all dependencies are found, false otherwise.
 */
export function dependencies(...bins: string[]): boolean {
    const missing = bins.filter((bin) => {
        try {
            exec(`which ${bin}`);
            return false;
        } catch (e) {
            console.error(e);
            return true;
        }
    });

    if (missing.length > 0) {
        console.warn(Error(`missing dependencies: ${missing.join(', ')}`));
        Notify({
            summary: 'Dependencies not found!',
            body: `The following dependencies are missing: ${missing.join(', ')}`,
            iconName: icons.ui.warning,
        });
    }

    return missing.length === 0;
}

/**
 * Launches an application in a detached process.
 *
 * This function runs the specified application executable in the background using a bash command.
 * It also increments the application's frequency counter.
 *
 * @param app The application to launch.
 */
export function launchApp(app: AstalApps.Application): void {
    const exe = app.executable
        .split(/\s+/)
        .filter((str) => !str.startsWith('%') && !str.startsWith('@'))
        .join(' ');

    bash(`${exe} &`);
    app.frequency += 1;
}

/**
 * Checks if the provided filepath is a valid image.
 *
 * This function attempts to load an image from the specified filepath using GdkPixbuf.
 * If the image is successfully loaded, it returns true. Otherwise, it logs an error and returns false.
 *
 * Note: Unlike GdkPixbuf, this function will normalize the given path.
 *
 * @param imgFilePath The path to the image file.
 *
 * @returns True if the filepath is a valid image, false otherwise.
 */
export function isAnImage(imgFilePath: string): boolean {
    try {
        GdkPixbuf.Pixbuf.new_from_file(normalizePath(imgFilePath));
        return true;
    } catch (error) {
        console.info(error);
        return false;
    }
}

/**
 * Normalize a path to the absolute representation of the path.
 *
 * Note: This will only expand '~' if present. Path traversal is not supported.
 *
 * @param path The path to normalize.
 *
 * @returns The normalized path.
 */
export function normalizePath(path: string): string {
    if (path.charAt(0) == '~') {
        // Replace will only replace the first match, in this case, the first character
        return path.replace('~', GLib.get_home_dir());
    }

    return path;
}

/**
 * Sends a notification using the `notify-send` command.
 *
 * This function constructs a notification command based on the provided notification arguments and executes it asynchronously.
 * It logs an error if the notification fails to send.
 *
 * @param notifPayload The notification arguments containing summary, body, appName, iconName, urgency, timeout, category, transient, and id.
 */
export function Notify(notifPayload: NotificationArgs): void {
    let command = 'notify-send';
    command += ` "${notifPayload.summary} "`;
    if (notifPayload.body) command += ` "${notifPayload.body}" `;
    if (notifPayload.appName) command += ` -a "${notifPayload.appName}"`;
    if (notifPayload.iconName) command += ` -i "${notifPayload.iconName}"`;
    if (notifPayload.urgency) command += ` -u "${notifPayload.urgency}"`;
    if (notifPayload.timeout !== undefined) command += ` -t ${notifPayload.timeout}`;
    if (notifPayload.category) command += ` -c "${notifPayload.category}"`;
    if (notifPayload.transient) command += ` -e`;
    if (notifPayload.id !== undefined) command += ` -r ${notifPayload.id}`;

    execAsync(command)
        .then()
        .catch((err) => {
            console.error(`Failed to send notification: ${err.message}`);
        });
}

/**
 * Maps a notification or OSD anchor position to an Astal window anchor.
 *
 * This function converts a position anchor from the notification or OSD settings to the corresponding Astal window anchor.
 *
 * @param pos The position anchor to convert.
 *
 * @returns The corresponding Astal window anchor.
 */
export function getPosition(pos: NotificationAnchor | OSDAnchor): Astal.WindowAnchor {
    const positionMap: PositionAnchor = {
        top: Astal.WindowAnchor.TOP,
        'top right': Astal.WindowAnchor.TOP | Astal.WindowAnchor.RIGHT,
        'top left': Astal.WindowAnchor.TOP | Astal.WindowAnchor.LEFT,
        bottom: Astal.WindowAnchor.BOTTOM,
        'bottom right': Astal.WindowAnchor.BOTTOM | Astal.WindowAnchor.RIGHT,
        'bottom left': Astal.WindowAnchor.BOTTOM | Astal.WindowAnchor.LEFT,
        right: Astal.WindowAnchor.RIGHT,
        left: Astal.WindowAnchor.LEFT,
    };

    return positionMap[pos] || Astal.WindowAnchor.TOP;
}

/**
 * Validates if a string is a valid GJS color.
 *
 * This function checks if the provided string is a valid color in GJS.
 * It supports named colors, hex colors, RGB, and RGBA formats.
 *
 * @param color The color string to validate.
 *
 * @returns True if the color is valid, false otherwise.
 */
export function isValidGjsColor(color: string): boolean {
    const colorLower = color.toLowerCase().trim();

    if (namedColors.has(colorLower)) {
        return true;
    }

    const hexColorRegex = /^#(?:[a-fA-F0-9]{3,4}|[a-fA-F0-9]{6,8})$/;

    const rgbRegex = /^rgb\(\s*(\d{1,3}%?\s*,\s*){2}\d{1,3}%?\s*\)$/;
    const rgbaRegex = /^rgba\(\s*(\d{1,3}%?\s*,\s*){3}(0|1|0?\.\d+)\s*\)$/;

    if (hexColorRegex.test(color)) {
        return true;
    }

    if (rgbRegex.test(colorLower) || rgbaRegex.test(colorLower)) {
        return true;
    }

    return false;
}

/**
 * Capitalizes the first letter of a string.
 *
 * This function takes a string and returns a new string with the first letter capitalized.
 *
 * @param str The string to capitalize.
 *
 * @returns The input string with the first letter capitalized.
 */
export function capitalizeFirstLetter(str: string): string {
    return str.charAt(0).toUpperCase() + str.slice(1);
}

/**
 * Retrieves the icon for the current distribution.
 *
 * This function returns the icon associated with the current distribution based on the `distroIcons` array.
 * If no icon is found, it returns a default icon.
 *
 * @returns The icon for the current distribution as a string.
 */
export function getDistroIcon(): string {
    const icon = distroIcons.find(([id]) => id === distro.id);
    return icon ? icon[1] : ''; // default icon if not found
}

/**
 * Checks if an event is a primary click.
 *
 * This function determines if the provided event is a primary click based on the button property.
 *
 * @param event The click event to check.
 *
 * @returns True if the event is a primary click, false otherwise.
 */
export const isPrimaryClick = (event: Astal.ClickEvent): boolean => event.button === Gdk.BUTTON_PRIMARY;

/**
 * Checks if an event is a secondary click.
 *
 * This function determines if the provided event is a secondary click based on the button property.
 *
 * @param event The click event to check.
 *
 * @returns True if the event is a secondary click, false otherwise.
 */
export const isSecondaryClick = (event: Astal.ClickEvent): boolean => event.button === Gdk.BUTTON_SECONDARY;

/**
 * Checks if an event is a middle click.
 *
 * This function determines if the provided event is a middle click based on the button property.
 *
 * @param event The click event to check.
 *
 * @returns True if the event is a middle click, false otherwise.
 */
export const isMiddleClick = (event: Astal.ClickEvent): boolean => event.button === Gdk.BUTTON_MIDDLE;

/**
 * Checks if an event is a scroll up.
 *
 * This function determines if the provided event is a scroll up based on the direction property.
 *
 * @param event The scroll event to check.
 *
 * @returns True if the event is a scroll up, false otherwise.
 */
export const isScrollUp = (event: Gdk.Event): boolean => {
    const [directionSuccess, direction] = event.get_scroll_direction();
    const [deltaSuccess, , yScroll] = event.get_scroll_deltas();

    if (directionSuccess && direction === Gdk.ScrollDirection.UP) {
        return true;
    }

    if (deltaSuccess && yScroll < 0) {
        return true;
    }

    return false;
};

/**
 * Checks if an event is a scroll down.
 *
 * This function determines if the provided event is a scroll down based on the direction property.
 *
 * @param event The scroll event to check.
 *
 * @returns True if the event is a scroll down, false otherwise.
 */
export const isScrollDown = (event: Gdk.Event): boolean => {
    const [directionSuccess, direction] = event.get_scroll_direction();
    const [deltaSuccess, , yScroll] = event.get_scroll_deltas();

    if (directionSuccess && direction === Gdk.ScrollDirection.DOWN) {
        return true;
    }

    if (deltaSuccess && yScroll > 0) {
        return true;
    }

    return false;
};