import Logger from '../../logger';
import { GenericPatchHandler, afterPatch } from '../patcher';
import { wrapReactClass, wrapReactType } from './react';

// TODO max size limit? could implement as a class extending map perhaps
type PatchedComponentCache = Map<any, any>;
export type GenericNodeStep = (node: any) => any;
// to patch a specific method of a class component other than render. TODO implement
// export type ClassNodeStep = [finder: GenericNodeStep, method: string];
// export type NodeStep = GenericNodeStep | ClassNodeStep;
export type NodeStep = GenericNodeStep;
export type ReactPatchHandler = GenericPatchHandler;

// These will get *very* spammy.
let loggingEnabled = false;
let perfLoggingEnabled = false;

export function setReactPatcherLoggingEnabled(value: boolean = true) { loggingEnabled = value };
export function setReactPatcherPerformanceLoggingEnabled(value: boolean = true) { perfLoggingEnabled = value };

function patchComponent(node: any, handler: GenericPatchHandler, steps: NodeStep[], step: number, caches: PatchedComponentCache[], logger: Logger, prop: string = 'type') {
    loggingEnabled && logger.group('Patching node:', node);
    // We need to take extra care to not mutate the original node.type
    switch (typeof node?.[prop]) {
        case 'function':
            // Function component
            const patch = afterPatch(node, prop, steps[step + 1] ? createStepHandler(handler, steps, step + 1, caches, logger) : handler);
            loggingEnabled && logger.debug('Patched a function component', patch);
            break;
        case 'object':
            if (node[prop]?.prototype?.render) {
                // Class component
                // TODO handle patching custom methods
                wrapReactClass(node);
                const patch = afterPatch(node[prop].prototype, 'render', steps[step + 1] ? createStepHandler(handler, steps, step + 1, caches, logger) : handler);
                loggingEnabled && logger.debug('Patched class component', patch);
            } else {
                loggingEnabled && logger.debug('Patching forwardref/memo');
                wrapReactType(node, prop);
                // Step down the object
                patchComponent(node[prop], handler, steps, step, caches, logger, node[prop]?.render ? 'render' : 'type'); 
            }
            break;
        default:
            logger.error('Unhandled component type', node);
            break;
    }
    loggingEnabled && logger.groupEnd();
}

function handleStep(tree: any, handler: GenericPatchHandler, steps: NodeStep[], step: number, caches: PatchedComponentCache[], logger: Logger): any {
    const startTime = (loggingEnabled || perfLoggingEnabled) ? performance.now() : 0;
    const stepHandler = steps[step];
    const cache = caches[step] || (caches[step] = new Map());
    loggingEnabled && logger.debug(`Patch step ${step} running`, { tree, stepHandler, step, caches });

    const node = stepHandler(tree);
    if (node && node.type) {
        loggingEnabled && logger.debug('Found node', node);
    } else if (node) {
        loggingEnabled && logger.error('Found node without type. Something is probably wrong.', node);
        return tree;
    } else {
        loggingEnabled && logger.warn('Found no node. Depending on your usecase, this might be fine.', node);
        return tree;
    }

    let cachedType;
    if (cachedType = cache.get(node.type)) {
        loggingEnabled && logger.debug('Found cached patched component', node);
        node.type = cachedType;
        (loggingEnabled || perfLoggingEnabled) && logger.debug(`Patch step ${step} took ${performance.now() - startTime}ms with cache`);
        return tree;
    }

    const originalType = node.type;

    patchComponent(node, handler, steps, step, caches, logger);

    cache.set(originalType, node.type);

    (loggingEnabled || perfLoggingEnabled) && logger.debug(`Patch step ${step} took ${performance.now() - startTime}ms`);
    return tree;
};

function createStepHandler(handler: GenericPatchHandler, steps: NodeStep[], step: number, caches: PatchedComponentCache[], logger: Logger) {
    loggingEnabled && logger.debug(`Creating handler for step ${step}`);
    return (_: any, tree: any) => handleStep(tree, handler, steps, step, caches, logger);
}

// TODO handle createReactTreePatcher inside handler and cache it (or warn)
export function createReactTreePatcher(steps: NodeStep[], handler: GenericPatchHandler, debugName: string = 'ReactPatch'): GenericPatchHandler {
    const caches: PatchedComponentCache[] = [];

    const logger = new Logger(`ReactTreePatcher -> ${debugName}`);

    loggingEnabled && logger.debug('Init with options:', steps, debugName);

    return createStepHandler(handler, steps, 0, caches, logger);
}