import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';
import { PlannedTermEra, PlannedTerm } from '@app/core/models/planned-term';
import { YearMapping } from '@app/core/models/year';

export const isValidTermCode = (anything: any): anything is string => {
  return /^\d{4}$/.test(anything);
};

export const pickTermName = (termOffset: string) => {
  switch (termOffset) {
    case '2':
    case '3':
      return 'fall';
    case '4':
      return 'spring';
    case '6':
      return 'summer';
    default:
      throw new Error(`'${termOffset}' is not a valid term offset`);
  }
};

export const parseTermCode = (termCode: string) => {
  if (isValidTermCode(termCode) === false) {
    throw new Error(`'${termCode}' is not a valid term code`);
  }

  const yearCode = termCode.substr(0, 3);
  const termOffset = termCode.substr(3, 1);
  const termName = pickTermName(termOffset);
  return {
    yearCode,
    termOffset,
    termName: termName as ReturnType<typeof pickTermName>,
  };
};

export const pickTermEra = (
  termCode: string,
  activeTermCodes: string[],
): PlannedTermEra => {
  const noActiveTermCodes = activeTermCodes.length === 0;
  const isActiveTermCode = activeTermCodes.some(tc => tc === termCode);
  const beforeAllActiveTermCodes = activeTermCodes.every(tc => tc > termCode);
  if (noActiveTermCodes || isActiveTermCode) {
    return 'active';
  } else if (beforeAllActiveTermCodes) {
    return 'past';
  } else {
    return 'future';
  }
};

export const pickYearEra = (
  yearCode: string,
  activeTermCodes: string[],
): PlannedTermEra => {
  const activeYearCodes = activeTermCodes.map(tc => tc.substr(0, 3));
  const noActiveYearCodes = activeYearCodes.length === 0;
  const isActiveYearCode = activeYearCodes.some(yc => yc === yearCode);
  const beforeAllActiveYearCodes = activeYearCodes.every(yc => yc > yearCode);
  if (noActiveYearCodes || isActiveYearCode) {
    return 'active';
  } else if (beforeAllActiveYearCodes) {
    return 'past';
  } else {
    return 'future';
  }
};

export const yearsToDropZoneIds = () => (years$: Observable<YearMapping>) => {
  return years$.pipe(
    map(years => {
      const yearCodes = Object.keys(years);
      const termCodes = yearCodes.reduce<string[]>((acc, yearCode) => {
        if (years[yearCode].fall.era !== 'past') {
          acc = acc.concat(years[yearCode].fall.termCode);
        }

        if (years[yearCode].spring.era !== 'past') {
          acc = acc.concat(years[yearCode].spring.termCode);
        }

        if (years[yearCode].summer.era !== 'past') {
          acc = acc.concat(years[yearCode].summer.termCode);
        }

        return acc;
      }, []);

      const termIds = [
        'saved-courses',
        ...termCodes.map(termCode => `term-${termCode}`),
      ];
      return termIds;
    }),
  );
};

export const compareStringArrays = (a: string[], b: string[]): boolean => {
  if (a.length === b.length) {
    return a.every((elem, i) => elem === b[i]);
  }

  return false;
};

export const yearsToYearCodes = () => (years$: Observable<YearMapping>) => {
  return years$.pipe(
    map(years => {
      const yearCodes = Object.keys(years);
      const sortedYearCodes = yearCodes.sort();
      return sortedYearCodes;
    }),
  );
};

export const yearsToDroppableTermCodes = () => (
  years$: Observable<YearMapping>,
) => {
  return years$.pipe(
    map(years => {
      const yearCodes = Object.keys(years);
      return yearCodes.reduce<string[]>((acc, yearCode) => {
        if (years[yearCode].fall.era !== 'past') {
          acc = acc.concat(years[yearCode].fall.termCode);
        }

        if (years[yearCode].spring.era !== 'past') {
          acc = acc.concat(years[yearCode].spring.termCode);
        }

        if (years[yearCode].summer.era !== 'past') {
          acc = acc.concat(years[yearCode].summer.termCode);
        }

        return acc;
      }, []);
    }),
  );
};