import { map, reduce, sort, range, omit, times } from 'rambda';
 import type { JobId } from '../../types';
 import { updateCTime } from '../johnson';
 import { min } from 'ramda';

 import { fillCorrupted } from '../campbel';

 
 type JobOperations = {
   jobId: JobId,

   operations: Array<{ t: number, name: string }>

 };
 
 type JobOperationsWithC = {
   jobId: JobId,

   operations: Array<{ t: number, c: number, name: string }>

 };
 
 export const createSchedule = (jobsOperations: JobOperations[], processorsCount: number): JobOperationsWithC[] => {

   jobsOperations = fillCorrupted(jobsOperations, processorsCount);

   const jobsOperationsWithKoefs = map((jobsOperation: JobOperations) => {
     const ej = jobsOperation.operations[0].t < jobsOperation.operations[processorsCount - 1].t
       ? 1 : -1;
     const daco = reduce(
       (acc, i) => min(jobsOperation.operations[i-1].t + jobsOperation.operations[i].t, acc),
       Infinity,
       range(1, processorsCount)
     );
 
     const koef = ej / daco;
 
     return { ...jobsOperation, koef };
   }, jobsOperations);
 
   let sortedJobsOperations = sort(
     (a: JobOperations, b: JobOperations) => {
       return b.koef - a.koef;
     },
     jobsOperationsWithKoefs
   );
 
   sortedJobsOperations = map(omit('koef'), sortedJobsOperations);
 
   return updateCTime(sortedJobsOperations, processorsCount);
 };
 
 export default (jobsOperations: JobOperations[], processorsCount: number) => {
   const schedule = createSchedule(jobsOperations, processorsCount);
 
   return times(i =>
     map((jobTime: JobOperationsWithC) => ({
       processor: i + 1,
       startTime: jobTime.operations[i].c - jobTime.operations[i].t,
       endTime: jobTime.operations[i].c,

       name: jobTime.operations[i].name

     }), schedule)
   , processorsCount);
 };