/**
 * Created by mm28969 on 11/8/16.
 */

// declare let d3;
import * as d3 from "d3";

import {convertValueToAttribute, OrientationEnum} from "../mmviz-common/index";

import {createViewModel, Layout} from "./layout";
import {LayoutScale} from "./scale";

export function stackLayoutCreator(orientationEnum = OrientationEnum.VERTICAL, colorScaleKey = "color") {

    // layout extender
    return function(dataModel, layoutScale: LayoutScale) {

        let xDomain, yDomain;

        if (OrientationEnum.VERTICAL === orientationEnum) {

            xDomain = d3.extent(dataModel.categoryArray);
            yDomain = [dataModel.valueMin, dataModel.valueMax];

        }
        else if (OrientationEnum.HORIZONTAL === orientationEnum) {

            xDomain = [dataModel.valueMin, dataModel.valueMax];
            yDomain = d3.extent(dataModel.categoryArray);
        }

        layoutScale.extendDomainX(xDomain).extendDomainY(yDomain);


        function layoutDatum(stackDataItem, stackData){

            let dLayout, dataKey,
                hasValue, category,
                x, x0, x1,
                y, y0, y1, yBase,
                width, height
            ;

            category = stackDataItem.data.category;
            dataKey = stackData.key + "_" + category;

            if (OrientationEnum.VERTICAL === orientationEnum) {

                y0 = layoutScale.yScale(stackDataItem[0]);
                y1 = layoutScale.yScale(stackDataItem[1]);
                hasValue = (!isNaN(y0) && !isNaN(y1));

                if (hasValue) {

                    x = layoutScale.xScale(category);

                    dLayout = {
                        key: dataKey,
                        xKey: category,
                        category: stackData.key,
                        x: x,
                        y: y1,
                        y0: y0
                    };
                }
            }
            else if (OrientationEnum.HORIZONTAL === orientationEnum) {

                x0 = layoutScale.xScale(stackDataItem[0]);
                x1 = layoutScale.xScale(stackDataItem[1]);
                hasValue = (!isNaN(x0) && !isNaN(x1));

                if (hasValue){

                    y = layoutScale.yScale(category);

                    dLayout = {
                        key: dataKey,
                        yKey: category,
                        category: stackData.key,
                        x: x1,
                        x0: x0,
                        y: y
                    };
                }
            }

            return dLayout;
        }

        // layouter
        return function(){

            let stackData, stackDataItem,
                key, color, dLayout, dModelLayout, dModelMap: any = {},
                viewModel: any = createViewModel();

            for (stackData of dataModel.dataArray) {

                key = stackData.key;
                color = layoutScale.mapValue(colorScaleKey, dataModel, stackData);

                dModelLayout = dModelMap[color.key];

                if (!dModelLayout) {
                    dModelLayout = {
                        key: color.key,
                        color: color,
                        category: color.key,
                        categoryAttr: "category-" + convertValueToAttribute(color.key),
                        dataArray: []
                    };
                    dModelMap[color.key] = dModelLayout;
                    viewModel.dataArray.push(dModelLayout);
                }

                for (stackDataItem of stackData) {

                    if (stackDataItem.original){

                        dLayout = layoutDatum(stackDataItem, stackData);
                        if (dLayout !== undefined){

                            // dLayout.color = color;
                            // dLayout.categoryAttr = "category-" + convertValueToAttribute(color.key);

                            if(dataModel.detailsMap){
                                dLayout.details = dataModel.detailsMap(stackDataItem.original);
                            }


                            dModelLayout.dataArray.push(dLayout);
                        }
                    }
                }

                if (OrientationEnum.VERTICAL === orientationEnum) {
                    dModelLayout.dataArray.sort((a, b) => {return a.xKey - b.xKey});
                }
                else {
                    dModelLayout.dataArray.sort((a, b) => {return a.yKey - b.yKey});
                }
            }

            return viewModel;
        }
    }
}