export interface IMapColumnStyleItem {
  [index: number]: object
}
export interface IMapColumnStyle {
  [key: string]: IMapColumnStyleItem // [column.key] : {0:{'color':''}}
}

// @dynamic
export class GridColumnColorScale {

  static columnColorScale: IMapColumnStyle = {};
  static colorScalePalette = ["#CCFF90", "#B2FF59", "#00E676", "#FFE57F", "#FFFF00", "#FFEA00", "#FF8A80", "#FF5252", "#FF1744"];

  static init(resultList, columns): any {
    let colorScaleSteps = {};
    let activeColumns = columns._results.filter((column) => {
      if (column.colorScale.type && !column.key) console.warn("[rd-key] required at " + column.text);

      return column.colorScale.type && column.key
    });

    activeColumns.forEach((column) => {
      let allColumnValues = resultList.filter((item) => !isNaN(item[column.key])).map((row) => { return row[column.key] });
      let min = Math.min(...allColumnValues);
      let max = Math.max(...allColumnValues);
      colorScaleSteps[column.key] = {};

      if (column.colorScale.type == "static") {
        if (!column.colorScale.color) console.warn("[colorScale.color] required at ", column.text);
      }
      else if (column.colorScale.type == "gradient" || column.colorScale.type == "reverseGradient") {
        if (!column.colorScale.color) console.warn("[colorScale.color] required at " + column.text);
        else if (!column.colorScale.color.includes("rgba")) console.warn("[colorScale.color] as rgba at ", column.text);
        else {
          let step = Math.ceil((max - min) / 9);

          for (let i = 0; i < 10; i++) {
            let limit = Math.ceil(min) + step * i;
            colorScaleSteps[column.key][limit] = column.colorScale.type == "gradient" ? (i + 1) / 10 : ((i * -1) + 10) / 10;
          }
        }
      }
      else if (column.colorScale.type == "regular" || column.colorScale.type == "irregular") {
        let _palette = [...this.colorScalePalette];
        let palette = column.colorScale.type == "regular" ? _palette : _palette.reverse();

        let step = Math.ceil((max - min) / (this.colorScalePalette.length - 1));

        for (let i = 0; i < this.colorScalePalette.length; i++) {
          let color = palette[i];
          let limit = Math.ceil(min) + step * i;
          colorScaleSteps[column.key][limit] = color;
        }
      }
    });

    activeColumns.forEach((column) => {
      this.columnColorScale[column.key] = {};
      let scaleStepList = Object.keys(colorScaleSteps[column.key]);

      column.template._projectedViews.forEach((row, index) => {
        let bg;
        this.columnColorScale[column.key][index] = {};
        let value = row.context.$implicit[column.key];

        switch (column.colorScale.type) {
          case "regular":
          case "irregular":
            for (let step of scaleStepList) {
              if (step >= value) {
                bg = colorScaleSteps[column.key][step];
                break;
              }
            }
            break;
          case "gradient":
          case "reverseGradient":
            let alpha;

            for (let step of scaleStepList) {
              if (step >= value) {
                alpha = colorScaleSteps[column.key][step];
                bg = column.colorScale.color + "," + alpha + ")";
                break;
              }
            }
            break;
          case "static":
            bg = column.colorScale.color;
            break;
        }

        this.columnColorScale[column.key][index] = { "background": bg };
      });
    });

    return this.columnColorScale;
  }
}