import { findIndex, find, map, propEq, reduce, sort, concat } from 'rambda';
import type { JobId } from '../../types';
import { max, remove, slice } from 'ramda';

type JobTime = {
  jobId: JobId,
  t: number,
  d: number,
};

const findLateJob = (jobTimes: JobTime[]) =>
  find(({ c, d }: JobTime) => c > d, jobTimes);

const findMaxTJob = (jobTimes: JobTime[]) =>
  reduce(
    (maxTJob: JobTime, jobTime: JobTime) => maxTJob.t > jobTime.t ? maxTJob : jobTime,
    { t: -Infinity },
    jobTimes
  );

const updateCTime = (jobTimes: JobTime[]) => {
  let prev = 0;

  const cj = map((jobTime: JobTime) => {
    prev += jobTime.t;

    return { ...jobTime, c: prev };
  }, jobTimes);

  return cj;
};

export const fillCorrupted = (jobs: JobTime[]) => map(
  ({ d, ...rest }) => ({ ...rest, d: d || 1000 }),
  jobs);

export const createSchedule = (jobs: JobTime[]) => {
  jobs = fillCorrupted(jobs);

  const F = sort((a: JobTime, b: JobTime) => a.d - b.d, jobs);
  const L = [];

  let cj = updateCTime(F);
  let lateJob;

  while (lateJob = findLateJob(cj)) {
    const lateJobIndex = findIndex(propEq('jobId', lateJob.jobId), cj);
    const jobsBeforeLateJob = slice(0, lateJobIndex + 1, cj);

    const maxTJob = findMaxTJob(jobsBeforeLateJob);
    const maxTJobIndex = findIndex(propEq('jobId', maxTJob.jobId), cj);

    cj = remove(maxTJobIndex, 1, cj);
    cj = updateCTime(cj);

    L.push(maxTJob);
  }

  const schedule = concat(cj, L);

  return updateCTime(schedule);
};

export default (jobs: JobTime[]) => {
  const schedule = createSchedule(jobs);

  const normalizedSchedule = map((jobTime: JobTime) => ({
    processor: 1,
    startTime: jobTime.c - jobTime.t,
    endTime: jobTime.c,
    delayed: max(0, jobTime.c - jobTime.d)
  }), schedule);

  return [normalizedSchedule];
};