import { invertObj, pluck, reduce } from "ramda"

export const originalNodes = [1, 3, 5, 10, 25, 50, 100];

export function createMarks(arr: Array<number>){
  const l = (arr[arr.length - 1] - arr[0]) / (arr.length - 1);
  return reduce((acc, v) => {
    const _idx = arr.indexOf(v);
    return { ...acc, [1 + _idx * l]: {label: `${v}X`, value: v} };
  }, {}, arr);
}

export const defaultMarks = createMarks(originalNodes);

interface MarksProps{
  [P: number]: {
    value: number;
  }
}
export function createAveragePoints(marks: MarksProps){
  const points = invertObj(pluck('value' as any, marks as any));
  const pointsKeys = Object.keys(points).map(Number);
  const averagePoints: any = {};
  let k = pointsKeys[0]
    , c = k;
  
  while (k <= pointsKeys[pointsKeys.length - 1]){
    if (points[k]){
      averagePoints[k] = points[k];
      c = k;
      k++;
      continue;
    }
    const _index = pointsKeys.findIndex(x => x === c);
    const _s = Number(points[pointsKeys[_index]]);
    const _e = Number(points[pointsKeys[_index + 1]]);
    const _l = (_e - _s) / (pointsKeys[_index + 1] - pointsKeys[_index]);
    averagePoints[k] = Number((_s + (k - c) * _l).toFixed(2));
    
    k++;
  }
  // console.log('averagePoints',averagePoints)
  
  return averagePoints;
}

export function findNearestTarget(arr: Array<number>, target: number){
  let mid,
    l = 0,
    r = arr.length - 1;
  
  while (r - l > 1){
    mid = Math.floor((l + r) / 2);
    target < arr[mid] ? r = mid : l = mid;
  }
  
  return Math.abs(target - arr[l]) <= Math.abs(target - arr[r]) ? arr[l] : arr[r];
}

export const defaultAveragePoints = createAveragePoints(defaultMarks);
export const defaultInvertAveragePoints = invertObj(defaultAveragePoints);