import { injectable, inject } from 'inversify';
import { IDropable, IDragable } from '../dnd';
import { OperatePositionEnum, OperateTypeEnum } from './types';
import { LinkedTree, LinkedTreeNode, IDisposable } from 'ts-toolset';

/** 树形拖拽接口 */
export interface ITreeDnd<N> extends IDragable, IDropable, IDisposable {

    readonly operatePosition?: OperatePositionEnum;

    readonly operateType?: OperateTypeEnum;

    readonly selectedTarget?: LinkedTreeNode<N>;

    readonly hoverTarget?: LinkedTreeNode<N>;

    readonly dragTarget?: LinkedTreeNode<N>;

    readonly dropTarget?: LinkedTreeNode<N>;

    onSelectNode: (node: LinkedTreeNode<N>) => void;

    onOverNode: (node: LinkedTreeNode<N>) => void;

    onClearSelected: () => void;

    onClearDrop: () => void;

    onClearOver: () => void;

}

/** 属性拖拽 */
@injectable()
export abstract class TreeDnd<N> implements ITreeDnd<N> {

    protected _operatePosition?: OperatePositionEnum;
    protected _operateType?: OperateTypeEnum;
    protected _selectedNode?: LinkedTreeNode<N>;
    protected _overNode?: LinkedTreeNode<N>;
    protected _contextMenuNode?: LinkedTreeNode<N>;
    protected _dragNode?: LinkedTreeNode<N>;
    protected _dropNode?: LinkedTreeNode<N>;

    get operatePosition() { return this._operatePosition; }

    get operateType() { return this._operateType; }

    get selectedNode() { return this._selectedNode; }

    get overNode() { return this._overNode; }

    get contextMenuNode() { return this._contextMenuNode; }

    get dragNode() { return this._dragNode; }

    get dropNode() { return this._dropNode; }

    //constructor(private _linkedTree: LinkedTree<N>) { }

    onOverNode(overNode: LinkedTreeNode<N>) {
        let isOver = !this._overNode || (this._overNode && this._overNode !== overNode);
        isOver && (this._overNode = overNode);
        this.abstractOnOverNode(overNode, isOver);
    }
    protected abstract abstractOnOverNode(overNode: LinkedTreeNode<N>, isOver: boolean): void;

    onSelectNode(selectNode: LinkedTreeNode<N>) {
        this._selectedNode = selectNode;
        this.abstractOnSelectNode(selectNode);
    }
    protected abstract abstractOnSelectNode(selectNode: LinkedTreeNode<N>): void;

    onContextMenu(node: LinkedTreeNode<N>) {
        this._contextMenuNode = node;
        this.abstractOnContextMenu(node);
    }
    protected abstract abstractOnContextMenu(node: LinkedTreeNode<N>): void;

    canDrop(overNode: LinkedTreeNode<N>) {
        return !!(this._dragNode && this._dragNode !== this._overNode && !overNode.hasAncestor(this._dragNode)) && this.abstractCanDrop(overNode);
    }
    protected abstract abstractCanDrop(overNode: LinkedTreeNode<N>): boolean;

    dragStart(dragNode: LinkedTreeNode<N>) {
        this._dragNode = dragNode;
        this._operateType = OperateTypeEnum.move;
        this.abstractDragStart(dragNode);
    }
    protected abstract abstractDragStart(dragNode: LinkedTreeNode<N>): void;

    dragOver(overNode: LinkedTreeNode<N>) {
        let canDrop = this.canDrop(overNode);
        this._dropNode = canDrop ? overNode : undefined;
        this.abstractDragOver(this._dropNode, canDrop);
        this._overNode = undefined;
    }
    protected abstract abstractDragOver(overNode: LinkedTreeNode<N> | undefined, canDrop: boolean): void;

    drop(dropNode: LinkedTreeNode<N>) {
        this._dropNode = dropNode;
        this.abstractDrop(dropNode);
    }
    protected abstract abstractDrop(dropNode: LinkedTreeNode<N>): void;

    dragEnd() {
        this._dragNode = undefined;
        this._dropNode = undefined;

        this._operatePosition = undefined;
        this._operateType = undefined;

        this.abstractDragEnd();
    }
    protected abstract abstractDragEnd(): void;

    onClearOver() {
        this._overNode = undefined;
        this.abstractOnClearOver();
    }
    protected abstract abstractOnClearOver(): void;

    onClearSelected() {
        this._selectedNode = undefined;
        this._contextMenuNode = undefined;
        this.abstractOnClearSelected();
    }
    protected abstract abstractOnClearSelected(): void;

    onClearDrop() {
        this._dropNode = undefined;
        this._overNode = undefined;
        this.abstractOnClearDrop();
    }
    protected abstract abstractOnClearDrop(): void;

    abstract dispose(): void;

}