import { chainCommands, deleteSelection, exitCode, joinBackward, joinDown, joinUp, lift, newlineInCode, selectNodeBackward, setBlockType, splitBlockKeepMarks, toggleMark, wrapIn } from 'prosemirror-commands';
import { redo, undo } from 'prosemirror-history';
import { Schema } from 'prosemirror-model';
import { splitListItem, wrapInList } from 'prosemirror-schema-list';
import { EditorState, NodeSelection, TextSelection, Transaction } from 'prosemirror-state';
import { liftTarget } from 'prosemirror-transform';
import { AclAugment, AclSelfEdit, Doc } from '../../../../fields/Doc';
import { GetEffectiveAcl } from '../../../../fields/util';
import { Utils } from '../../../../Utils';
import { Docs } from '../../../documents/Documents';
import { RTFMarkup } from '../../../util/RTFMarkup';
import { SelectionManager } from '../../../util/SelectionManager';
import { OpenWhere } from '../DocumentView';
import { liftListItem, sinkListItem } from './prosemirrorPatches.js';

const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;

export type KeyMap = { [key: string]: any };

export let updateBullets = (tx2: Transaction, schema: Schema, assignedMapStyle?: string, from?: number, to?: number) => {
    let mapStyle = assignedMapStyle;
    tx2.doc.descendants((node: any, offset: any, index: any) => {
        if ((from === undefined || to === undefined || (from <= offset + node.nodeSize && to >= offset)) && (node.type === schema.nodes.ordered_list || node.type === schema.nodes.list_item)) {
            const path = (tx2.doc.resolve(offset) as any).path;
            let depth = Array.from(path).reduce((p: number, c: any) => p + (c.hasOwnProperty('type') && c.type === schema.nodes.ordered_list ? 1 : 0), 0);
            if (node.type === schema.nodes.ordered_list) {
                if (depth === 0 && !assignedMapStyle) mapStyle = node.attrs.mapStyle;
                depth++;
            }
            tx2.setNodeMarkup(offset, node.type, { ...node.attrs, mapStyle, bulletStyle: depth }, node.marks);
        }
    });
    return tx2;
};

export function buildKeymap<S extends Schema<any>>(schema: S, props: any, mapKeys?: KeyMap): KeyMap {
    const keys: { [key: string]: any } = {};

    function bind(key: string, cmd: any) {
        if (mapKeys) {
            const mapped = mapKeys[key];
            if (mapped === false) return;
            if (mapped) key = mapped;
        }
        keys[key] = cmd;
    }

    const canEdit = (state: any) => {
        switch (GetEffectiveAcl(props.DataDoc)) {
            case AclAugment:
                return false;
            case AclSelfEdit:
                for (var i = state.selection.from; i < state.selection.to; i++) {
                    const marks = state.doc.resolve(i)?.marks?.();
                    if (marks?.some((mark: any) => mark.type === schema.marks.user_mark && mark.attrs.userid !== Doc.CurrentUserEmail)) {
                        return false;
                    }
                }
                break;
        }
        return true;
    };

    const toggleEditableMark = (mark: any) => (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && toggleMark(mark)(state, dispatch);

    //History commands
    bind('Mod-z', undo);
    bind('Shift-Mod-z', redo);
    !mac && bind('Mod-y', redo);

    //Commands to modify Mark
    bind('Mod-b', toggleEditableMark(schema.marks.strong));
    bind('Mod-B', toggleEditableMark(schema.marks.strong));

    bind('Mod-e', toggleEditableMark(schema.marks.em));
    bind('Mod-E', toggleEditableMark(schema.marks.em));

    bind('Mod-*', toggleEditableMark(schema.marks.code));

    bind('Mod-u', toggleEditableMark(schema.marks.underline));
    bind('Mod-U', toggleEditableMark(schema.marks.underline));

    //Commands for lists
    bind('Ctrl-i', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && wrapInList(schema.nodes.ordered_list)(state as any, dispatch as any));

    bind('Ctrl-Tab', () => (props.onKey?.(event, props) ? true : true));
    bind('Alt-Tab', () => (props.onKey?.(event, props) ? true : true));
    bind('Meta-Tab', () => (props.onKey?.(event, props) ? true : true));
    bind('Meta-Enter', () => (props.onKey?.(event, props) ? true : true));
    bind('Tab', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        if (props.onKey?.(event, props)) return true;
        if (!canEdit(state)) return true;
        const ref = state.selection;
        const range = ref.$from.blockRange(ref.$to);
        const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
        if (
            !sinkListItem(schema.nodes.list_item)(state, (tx2: Transaction) => {
                const tx3 = updateBullets(tx2, schema);
                marks && tx3.ensureMarks([...marks]);
                marks && tx3.setStoredMarks([...marks]);
                dispatch(tx3);
            })
        ) {
            // couldn't sink into an existing list, so wrap in a new one
            const newstate = state.applyTransaction(state.tr.setSelection(TextSelection.create(state.doc, range!.start, range!.end)));
            if (
                !wrapInList(schema.nodes.ordered_list)(newstate.state as any, (tx2: Transaction) => {
                    const tx3 = updateBullets(tx2, schema);
                    // when promoting to a list, assume list will format things so don't copy the stored marks.
                    marks && tx3.ensureMarks([...marks]);
                    marks && tx3.setStoredMarks([...marks]);
                    dispatch(tx3);
                })
            ) {
                console.log('bullet promote fail');
            }
        }
    });

    bind('Shift-Tab', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        if (props.onKey?.(event, props)) return true;
        if (!canEdit(state)) return true;
        const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());

        if (
            !liftListItem(schema.nodes.list_item)(state.tr, (tx2: Transaction) => {
                const tx3 = updateBullets(tx2, schema);
                marks && tx3.ensureMarks([...marks]);
                marks && tx3.setStoredMarks([...marks]);
                dispatch(tx3);
            })
        ) {
            console.log('bullet demote fail');
        }
    });

    //Command to create a new Tab with a PDF of all the command shortcuts
    bind('Mod-/', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        const newDoc = Docs.Create.PdfDocument(Utils.prepend('/assets/cheat-sheet.pdf'), { _width: 300, _height: 300 });
        props.addDocTab(newDoc, OpenWhere.addRight);
    });

    //Commands to modify BlockType
    bind('Ctrl->', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state && wrapIn(schema.nodes.blockquote)(state as any, dispatch as any)));
    bind('Alt-\\', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && setBlockType(schema.nodes.paragraph)(state as any, dispatch as any));
    bind('Shift-Ctrl-\\', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && setBlockType(schema.nodes.code_block)(state as any, dispatch as any));

    bind('Ctrl-m', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        if (canEdit(state)) {
            const tr = state.tr.replaceSelectionWith(schema.nodes.equation.create({ fieldKey: 'math' + Utils.GenerateGuid() }));
            dispatch(tr.setSelection(new NodeSelection(tr.doc.resolve(tr.selection.$from.pos - 1))));
        }
    });

    for (let i = 1; i <= 6; i++) {
        bind('Shift-Ctrl-' + i, (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && setBlockType(schema.nodes.heading, { level: i })(state as any, dispatch as any));
    }

    //Command to create a horizontal break line
    const hr = schema.nodes.horizontal_rule;
    bind('Mod-_', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && dispatch(state.tr.replaceSelectionWith(hr.create()).scrollIntoView()));

    //Command to unselect all
    bind('Escape', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        dispatch(state.tr.setSelection(TextSelection.create(state.doc, state.selection.from, state.selection.from)));
        (document.activeElement as any).blur?.();
        SelectionManager.DeselectAll();
    });

    const splitMetadata = (marks: any, tx: Transaction) => {
        marks && tx.ensureMarks(marks.filter((val: any) => val.type !== schema.marks.metadata && val.type !== schema.marks.metadataKey && val.type !== schema.marks.metadataVal));
        marks && tx.setStoredMarks(marks.filter((val: any) => val.type !== schema.marks.metadata && val.type !== schema.marks.metadataKey && val.type !== schema.marks.metadataVal));
        return tx;
    };

    bind('Alt-Enter', () => (props.onKey?.(event, props) ? true : true));
    bind('Ctrl-Enter', () => (props.onKey?.(event, props) ? true : true));
    bind('Cmd-a', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        dispatch(state.tr.setSelection(new TextSelection(state.doc.resolve(1), state.doc.resolve(state.doc.content.size - 1))));
        return true;
    });
    bind('Cmd-?', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        RTFMarkup.Instance.open();
        return true;
    });
    bind('Cmd-e', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        if (!state.selection.empty) {
            const mark = state.schema.marks.summarizeInclusive.create();
            const tr = state.tr.addMark(state.selection.$from.pos, state.selection.$to.pos, mark);
            const content = tr.selection.content();
            tr.selection.replaceWith(tr, schema.nodes.summary.create({ visibility: false, text: content, textslice: content.toJSON() }));
            dispatch(tr);
        }
        return true;
    });
    bind('Cmd-]', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        const resolved = state.doc.resolve(state.selection.from) as any;
        const tr = state.tr;
        if (resolved?.parent.type.name === 'paragraph') {
            tr.setNodeMarkup(resolved.path[resolved.path.length - 4], schema.nodes.paragraph, { ...resolved.parent.attrs, align: 'right' }, resolved.parent.marks);
        } else {
            const node = resolved.nodeAfter;
            const sm = state.storedMarks || undefined;
            if (node) {
                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'right' })).setStoredMarks([...node.marks, ...(sm ? sm : [])]);
            }
        }
        dispatch(tr);
        return true;
    });
    bind('Cmd-\\', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        const resolved = state.doc.resolve(state.selection.from) as any;
        const tr = state.tr;
        if (resolved?.parent.type.name === 'paragraph') {
            tr.setNodeMarkup(resolved.path[resolved.path.length - 4], schema.nodes.paragraph, { ...resolved.parent.attrs, align: 'center' }, resolved.parent.marks);
        } else {
            const node = resolved.nodeAfter;
            const sm = state.storedMarks || undefined;
            if (node) {
                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'center' })).setStoredMarks([...node.marks, ...(sm ? sm : [])]);
            }
        }
        dispatch(tr);
        return true;
    });
    bind('Cmd-[', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        const resolved = state.doc.resolve(state.selection.from) as any;
        const tr = state.tr;
        if (resolved?.parent.type.name === 'paragraph') {
            tr.setNodeMarkup(resolved.path[resolved.path.length - 4], schema.nodes.paragraph, { ...resolved.parent.attrs, align: 'left' }, resolved.parent.marks);
        } else {
            const node = resolved.nodeAfter;
            const sm = state.storedMarks || undefined;
            if (node) {
                tr.replaceRangeWith(state.selection.from, state.selection.from, schema.nodes.paragraph.create({ align: 'left' })).setStoredMarks([...node.marks, ...(sm ? sm : [])]);
            }
        }
        dispatch(tr);
        return true;
    });

    bind('Cmd-f', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        const content = state.tr.selection.empty ? undefined : state.tr.selection.content().content.textBetween(0, state.tr.selection.content().size + 1);
        const newNode = schema.nodes.footnote.create({}, content ? state.schema.text(content) : undefined);
        const tr = state.tr;
        tr.replaceSelectionWith(newNode); // replace insertion with a footnote.
        dispatch(
            tr.setSelection(
                new NodeSelection( // select the footnote node to open its display
                    tr.doc.resolve(
                        // get the location of the footnote node by subtracting the nodesize of the footnote from the current insertion point anchor (which will be immediately after the footnote node)
                        tr.selection.anchor - (tr.selection.$anchor.nodeBefore?.nodeSize || 0)
                    )
                )
            )
        );
        return true;
    });

    bind('Ctrl-a', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        dispatch(state.tr.setSelection(new TextSelection(state.doc.resolve(1), state.doc.resolve(state.doc.content.size - 1))));
        return true;
    });

    // backspace = chainCommands(deleteSelection, joinBackward, selectNodeBackward);
    bind('Backspace', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        if (props.onKey?.(event, props)) return true;
        if (!canEdit(state)) return true;

        if (
            !deleteSelection(state, (tx: Transaction) => {
                dispatch(updateBullets(tx, schema));
            })
        ) {
            if (
                !joinBackward(state, (tx: Transaction) => {
                    dispatch(updateBullets(tx, schema));
                })
            ) {
                if (
                    !selectNodeBackward(state, (tx: Transaction) => {
                        dispatch(updateBullets(tx, schema));
                    })
                ) {
                    return false;
                }
            }
        }
        return true;
    });

    //newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock
    //command to break line
    bind('Enter', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        if (props.onKey?.(event, props)) return true;
        if (!canEdit(state)) return true;

        const trange = state.selection.$from.blockRange(state.selection.$to);
        const path = (state.selection.$from as any).path;
        const depth = trange ? liftTarget(trange) : undefined;
        const split = path.length > 5 && !path[path.length - 3].textContent && path[path.length - 6].type !== schema.nodes.list_item;
        if (split && trange && depth !== undefined && depth !== null) {
            dispatch(state.tr.lift(trange, depth) as any);
            return true;
        }

        const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
        const cr = state.selection.$from.node().textContent.endsWith('\n');
        if (cr || !newlineInCode(state, dispatch as any)) {
            if (
                !splitListItem(schema.nodes.list_item)(state as any, (tx2: Transaction) => {
                    const tx3 = updateBullets(tx2, schema);
                    marks && tx3.ensureMarks([...marks]);
                    marks && tx3.setStoredMarks([...marks]);
                    dispatch(tx3);
                })
            ) {
                const fromattrs = state.selection.$from.node().attrs;
                if (
                    !splitBlockKeepMarks(state, (tx3: Transaction) => {
                        const tonode = tx3.selection.$to.node();
                        if (tx3.selection.to && tx3.doc.nodeAt(tx3.selection.to - 1)) {
                            const tx4 = tx3.setNodeMarkup(tx3.selection.to - 1, tonode.type, fromattrs, tonode.marks);
                            splitMetadata(marks, tx4);
                            if (!liftListItem(schema.nodes.list_item)(tx4, dispatch as (tx: Transaction) => void)) {
                                dispatch(tx4);
                            }
                        } else dispatch(tx3.insertText('\r\n'));
                    })
                ) {
                    return false;
                }
            }
        }
        return true;
    });

    //Command to create a blank space
    bind('Space', (state: EditorState, dispatch: (tx: Transaction) => void) => {
        if (!canEdit(state)) return true;
        const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());
        dispatch(splitMetadata(marks, state.tr));
        return false;
    });

    bind('Alt-ArrowUp', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && joinUp(state, dispatch as any));
    bind('Alt-ArrowDown', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && joinDown(state, dispatch as any));
    bind('Mod-BracketLeft', (state: EditorState, dispatch: (tx: Transaction) => void) => canEdit(state) && lift(state, dispatch as any));

    const cmd = chainCommands(exitCode, (state, dispatch) => {
        if (dispatch) {
            canEdit(state) && dispatch(state.tr.replaceSelectionWith(schema.nodes.hard_break.create()).scrollIntoView());
            return true;
        }
        return false;
    });

    bind('Shift-Enter', cmd);

    return keys;
}