export type HSV = [number, number, number];
export type RGBA = [number, number, number, number] | Uint8ClampedArray;

export class ColorPicker {
  public hsvData: HSV;

  constructor(pixelData: RGBA) {
    this.hsvData = this.RGBtoHSV(pixelData);
  }

  public selectedColorRange() {
    return this.widenRange([[...this.hsvData], [...this.hsvData]]);
  }

  public expandColorRange(currentRange: [HSV, HSV]) {
    const widenedHSV = this.widenRange([[...this.hsvData], [...this.hsvData]]);
    return this.createRange(currentRange.concat(widenedHSV));
  }

  public shrinkColorRange(currentRange: [HSV, HSV]) {
    const widenedHSV = this.widenRange([[...this.hsvData], [...this.hsvData]]);

    //Tries to shrink the lower part of to widened HSV
    if (!this.shrinkRange(currentRange, widenedHSV[0])) {
      //If the prev attempt failed, try to shrink the higher part of to widened HSV
      this.shrinkRange(currentRange, widenedHSV[1]);
    }

    return currentRange;
  }

  private createRange(range: HSV[]): [HSV, HSV] {
    const newRange: [HSV, HSV] = [
      [0, 0, 0],
      [0, 0, 0]
    ];
    for (let i = 0; i < 3; i++) {
      newRange[0][i] = range[0][i];
      newRange[1][i] = range[0][i];
      for (let j = range.length - 1; j >= 0; j--) {
        newRange[0][i] = Math.min(range[j][i], newRange[0][i]);
        newRange[1][i] = Math.max(range[j][i], newRange[1][i]);
      }
    }
    return newRange;
  }

  private widenRange(range: [HSV, HSV]): [HSV, HSV] {
    const expanded: [HSV, HSV] = [
      [0, 0, 0],
      [0, 0, 0]
    ];
    for (let i = 0; i < 3; i++) {
      //Expanding the range by 10
      expanded[0][i] = Math.max(0, range[0][i] - 10);
      expanded[1][i] = Math.min(255, range[1][i] + 10);
    }
    expanded[1][0] = Math.min(180, expanded[1][0]); //h is up to 180
    return expanded;
  }

  private shrinkRange(range: [HSV, HSV], color: HSV): boolean {
    for (let i = 0; i < color.length; i++) {
      if (!(range[0][i] <= color[i] && color[i] <= range[1][i])) return false;
    }

    for (let i = 0; i < color.length; i++) {
      if (color[i] - range[0][i] < range[1][i] - color[i]) {
        //shrink from min side
        range[0][i] = Math.min(range[0][i] + 10, range[1][i]);
      } else {
        //shrink from max side
        range[1][i] = Math.max(range[1][i] - 10, range[0][i]);
      }
    }

    return true;
  }

  private RGBtoHSV(rgba: RGBA): HSV {
    // Normalize RGB ranges
    let r = rgba[0],
      g = rgba[1],
      b = rgba[2];
    r = r / 255;
    g = g / 255;
    b = b / 255;

    const minRGB = Math.min(r, Math.min(g, b));
    const maxRGB = Math.max(r, Math.max(g, b));
    const d = r === minRGB ? g - b : b === minRGB ? r - g : b - r;
    const h = r === minRGB ? 3 : b === minRGB ? 1 : 5;
    let H = 30 * (h - d / (maxRGB - minRGB));
    let S = (255 * (maxRGB - minRGB)) / maxRGB;
    let V = 255 * maxRGB;
    if (isNaN(H)) H = 0;
    if (isNaN(S)) S = 0;
    if (isNaN(V)) V = 0;
    return [Math.round(H), Math.round(S), Math.round(V)];
  }
}