/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied.  See the License for the
* specific language governing permissions and limitations
* under the License.
*/

import * as zrUtil from 'zrender/src/core/util';
import {parseClassType, ClassManager} from './clazz';
import { ComponentOption, ComponentMainType, ComponentSubType, ComponentFullType } from './types';
import { Dictionary } from 'zrender/src/core/types';
import { makePrintable } from './log';

// A random offset
let base = Math.round(Math.random() * 10);


/**
 * @public
 * @param {string} type
 * @return {string}
 */
export function getUID(type: string): string {
    // Considering the case of crossing js context,
    // use Math.random to make id as unique as possible.
    return [(type || ''), base++].join('_');
}

export interface SubTypeDefaulter {
    // return subType.
    (option: ComponentOption): ComponentSubType;
}

export interface SubTypeDefaulterManager {
    registerSubTypeDefaulter: (componentType: string, defaulter: SubTypeDefaulter) => void;
    determineSubType: (componentType: string, option: ComponentOption) => string;
}

/**
 * Implements `SubTypeDefaulterManager` for `target`.
 */
export function enableSubTypeDefaulter(target: SubTypeDefaulterManager & ClassManager): void {
    const subTypeDefaulters: Dictionary<SubTypeDefaulter> = {};

    target.registerSubTypeDefaulter = function (
        componentType: ComponentFullType,
        defaulter: SubTypeDefaulter
    ): void {
        const componentTypeInfo = parseClassType(componentType);
        subTypeDefaulters[componentTypeInfo.main] = defaulter;
    };

    target.determineSubType = function (
        componentType: ComponentFullType,
        option: ComponentOption
    ): string {
        let type = option.type;
        if (!type) {
            const componentTypeMain = parseClassType(componentType).main;
            if (target.hasSubTypes(componentType) && subTypeDefaulters[componentTypeMain]) {
                type = subTypeDefaulters[componentTypeMain](option);
            }
        }
        return type;
    };
}

export interface TopologicalTravelable<T> {
    topologicalTravel: (
        targetNameList: ComponentMainType[],
        fullNameList: ComponentMainType[],
        callback: (this: T, mainType: string, dependencies: string[]) => void,
        context?: T
    ) => void;
}


// ComponentMainType can be 'bb' or 'aa.xx'.
type DepGraphItem = {
    predecessor: ComponentMainType[],
    successor: ComponentMainType[],
    originalDeps: ComponentMainType[],
    entryCount: number
};
type DepGraph = {[cmptMainType: string]: DepGraphItem};

/**
 * Implements `TopologicalTravelable<any>` for `entity`.
 *
 * Topological travel on Activity Network (Activity On Vertices).
 * Dependencies is defined in Model.prototype.dependencies, like ['xAxis', 'yAxis'].
 * If 'xAxis' or 'yAxis' is absent in componentTypeList, just ignore it in topology.
 * If there is circular dependencey, Error will be thrown.
 */
export function enableTopologicalTravel<T>(
    entity: TopologicalTravelable<T>,
    dependencyGetter: (name: ComponentMainType) => ComponentMainType[]
): void {

    /**
     * @param targetNameList Target Component type list.
     *                       Can be ['aa', 'bb', 'aa.xx']
     * @param fullNameList By which we can build dependency graph.
     * @param callback Params: componentType, dependencies.
     * @param context Scope of callback.
     */
    entity.topologicalTravel = function<Ctx> (
        targetNameList: ComponentMainType[],
        fullNameList: ComponentMainType[],
        callback: (this: Ctx, mainType: ComponentMainType, dependencies: ComponentMainType[]) => void,
        context?: Ctx
    ) {
        if (!targetNameList.length) {
            return;
        }

        const result = makeDepndencyGraph(fullNameList);
        const graph = result.graph;
        const noEntryList = result.noEntryList;

        const targetNameSet: {[cmtpMainType: string]: boolean} = {};
        zrUtil.each(targetNameList, function (name) {
            targetNameSet[name] = true;
        });

        while (noEntryList.length) {
            const currComponentType = noEntryList.pop();
            const currVertex = graph[currComponentType];
            const isInTargetNameSet = !!targetNameSet[currComponentType];
            if (isInTargetNameSet) {
                callback.call(context, currComponentType, currVertex.originalDeps.slice());
                delete targetNameSet[currComponentType];
            }
            zrUtil.each(
                currVertex.successor,
                isInTargetNameSet ? removeEdgeAndAdd : removeEdge
            );
        }

        zrUtil.each(targetNameSet, function () {
            let errMsg = '';
            if (__DEV__) {
                errMsg = makePrintable('Circular dependency may exists: ', targetNameSet, targetNameList, fullNameList);
            }
            throw new Error(errMsg);
        });

        function removeEdge(succComponentType: ComponentMainType): void {
            graph[succComponentType].entryCount--;
            if (graph[succComponentType].entryCount === 0) {
                noEntryList.push(succComponentType);
            }
        }

        // Consider this case: legend depends on series, and we call
        // chart.setOption({series: [...]}), where only series is in option.
        // If we do not have 'removeEdgeAndAdd', legendModel.mergeOption will
        // not be called, but only sereis.mergeOption is called. Thus legend
        // have no chance to update its local record about series (like which
        // name of series is available in legend).
        function removeEdgeAndAdd(succComponentType: ComponentMainType): void {
            targetNameSet[succComponentType] = true;
            removeEdge(succComponentType);
        }
    };

    function makeDepndencyGraph(fullNameList: ComponentMainType[]) {
        const graph: DepGraph = {};
        const noEntryList: ComponentMainType[] = [];

        zrUtil.each(fullNameList, function (name: ComponentMainType) {

            const thisItem = createDependencyGraphItem(graph, name);
            const originalDeps = thisItem.originalDeps = dependencyGetter(name);

            const availableDeps = getAvailableDependencies(originalDeps, fullNameList);
            thisItem.entryCount = availableDeps.length;
            if (thisItem.entryCount === 0) {
                noEntryList.push(name);
            }

            zrUtil.each(availableDeps, function (dependentName) {
                if (zrUtil.indexOf(thisItem.predecessor, dependentName) < 0) {
                    thisItem.predecessor.push(dependentName);
                }
                const thatItem = createDependencyGraphItem(graph, dependentName);
                if (zrUtil.indexOf(thatItem.successor, dependentName) < 0) {
                    thatItem.successor.push(name);
                }
            });
        });

        return {graph: graph, noEntryList: noEntryList};
    }

    function createDependencyGraphItem(graph: DepGraph, name: ComponentMainType) {
        if (!graph[name]) {
            graph[name] = {predecessor: [], successor: []} as DepGraphItem;
        }
        return graph[name];
    }

    function getAvailableDependencies(
        originalDeps: ComponentMainType[], fullNameList: ComponentMainType[]
    ): ComponentMainType[] {
        const availableDeps = [] as ComponentMainType[];
        zrUtil.each(originalDeps, function (dep) {
            zrUtil.indexOf(fullNameList, dep) >= 0 && availableDeps.push(dep);
        });
        return availableDeps;
    }

}

export function inheritDefaultOption<T, K>(superOption: T, subOption: K): K {
    // See also `model/Component.ts#getDefaultOption`
    return zrUtil.merge(zrUtil.merge({}, superOption, true), subOption, true);
}