import type { Str, U } from './index.mjs';

/**
 * Positive numeric digits as strings
 */
export type PosDigit = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';

/**
 * All numeric digits as strings
 */
export type Digit = '0' | PosDigit;

/**
 * Type that will return the incoming type if the value is a valid positive integer,
 * or `never` otherwise.
 * @example
 * ```ts
 * PosNum<'321'> => '321'
 * PosNum<'0'> => never
 * ```
 */
export type PosNum<N extends string> =
  N extends Str.Append<PosDigit, infer Rest>
    ? Rest extends Str.TakeWhile<Rest, Digit>
      ? N
      : never
    : never;

/**
 * Type that will return the incoming type if the value is a valid natural number,
 * or `never` otherwise.
 * @example
 * ```ts
 * NatNum<'321'> => '321'
 * NatNum<'0'> => '0'
 * ```
 */
export type NatNum<N extends string> = N extends '0' ? '0' : PosNum<N>;

/**
 * Returns true if the given string is a valid positive integer, false otherwise.
 * @example
 * ```ts
 * IsPosNum<5> => true
 * IsPosNum<0> => false
 * IsPosNum<-5> => false
 * ```
 */
export type IsPosNum<N extends string> =
  N extends Str.Append<PosDigit, infer Rest>
    ? Str.DropWhile<Rest, Digit> extends ''
      ? true
      : false
    : false;

/**
 * Returns true if the given string is a valid natural number, false otherwise.
 * @example
 * ```ts
 * IsNatNum<5> => true
 * IsNatNum<0> => true
 * IsNatNum<-5> => false
 * ```
 */
export type IsNatNum<N extends string> = N extends '0' ? true : IsPosNum<N>;

/**
 * Type that validates whether a given string-number is even.
 * Checks that the last digit is even.
 */
export type IsEven<N extends string> = U.Pred<
  Str.EndsWith<N, '0' | '2' | '4' | '6' | '8'>
>;

/**
 * Type that validates whether a given string-number is odd.
 * Checks that the last digit is odd.
 */
export type IsOdd<N extends string> = U.Pred<
  Str.EndsWith<N, '1' | '3' | '5' | '7' | '9'>
>;

/**
 * A symmetric tuple, where the order or the elements does not matter.
 * As an example: SymTup<'a', 1> is equal to SymTup<1, 'a'>
 */
export type SymTup<A, B> = [A, B] | [B, A];

/**
 * Given two string digits, this type returns a tuple of which the first element
 * is the digit resulting from addition of the two digits, and the second element
 * is a boolean indicating whether there was an overflow.
 * @example
 * ```ts
 * AddDigit<'1', '2'> => ['3', false]
 * AddDigit<'8', '4'> => ['2', true]
 * ```
 */
export type AddDigit<D1 extends Digit, D2 extends Digit> = D1 extends '0'
  ? [D2, false]
  : D2 extends '0'
    ? [D1, false]
    : [D1, D2] extends
          | SymTup<'1', '9'>
          | SymTup<'2', '8'>
          | SymTup<'3', '7'>
          | SymTup<'4', '6'>
          | '5'[]
      ? ['0', true]
      : [D1, D2] extends
            | SymTup<'2', '9'>
            | SymTup<'3', '8'>
            | SymTup<'4', '7'>
            | SymTup<'5', '6'>
        ? ['1', true]
        : [D1, D2] extends '1'[]
          ? ['2', false]
          : [D1, D2] extends
                | SymTup<'3', '9'>
                | SymTup<'4', '8'>
                | SymTup<'5', '7'>
                | '6'[]
            ? ['2', true]
            : [D1, D2] extends SymTup<'1', '2'>
              ? ['3', false]
              : [D1, D2] extends
                    | SymTup<'4', '9'>
                    | SymTup<'5', '8'>
                    | SymTup<'6', '7'>
                ? ['3', true]
                : [D1, D2] extends SymTup<'1', '3'> | '2'[]
                  ? ['4', false]
                  : [D1, D2] extends SymTup<'5', '9'> | SymTup<'6', '8'> | '7'[]
                    ? ['4', true]
                    : [D1, D2] extends SymTup<'1', '4'> | SymTup<'2', '3'>
                      ? ['5', false]
                      : [D1, D2] extends SymTup<'6', '9'> | SymTup<'7', '8'>
                        ? ['5', true]
                        : [D1, D2] extends
                              | SymTup<'1', '5'>
                              | SymTup<'2', '4'>
                              | '3'[]
                          ? ['6', false]
                          : [D1, D2] extends SymTup<'7', '9'> | '8'[]
                            ? ['6', true]
                            : [D1, D2] extends
                                  | SymTup<'1', '6'>
                                  | SymTup<'2', '5'>
                                  | SymTup<'3', '4'>
                              ? ['7', false]
                              : [D1, D2] extends SymTup<'8', '9'>
                                ? ['7', true]
                                : [D1, D2] extends
                                      | SymTup<'1', '7'>
                                      | SymTup<'2', '6'>
                                      | SymTup<'3', '5'>
                                      | '4'[]
                                  ? ['8', false]
                                  : [D1, D2] extends '9'[]
                                    ? ['8', true]
                                    : [D1, D2] extends
                                          | SymTup<'1', '8'>
                                          | SymTup<'2', '7'>
                                          | SymTup<'3', '6'>
                                          | SymTup<'4', '5'>
                                      ? ['9', false]
                                      : never;

/**
 * Returns the result of adding the two given string-numbers.
 * @example
 * ```ts
 * SAdd<'13', '8'> => '21'
 * SAdd<'139', '5232'> => '5371'
 * ```
 */
export type Add<N1 extends string, N2 extends string> =
  // Check if N1 is non-empty
  N1 extends Str.Append<infer N1Start, Digit>
    ? // Check if N2 is non-empty
      N2 extends Str.Append<infer N2Start, Digit>
      ? // Retrieve last digit of N1
        N1 extends Str.Append<N1Start, infer N1LastDigit>
        ? // Retrieve last digit of N2
          N2 extends Str.Append<N2Start, infer N2LastDigit>
          ? // Calculate new digit and overflow
            AddDigit<N1LastDigit & Digit, N2LastDigit & Digit> extends [
              infer NewDigit,
              infer Overflow,
            ]
            ? Overflow extends true
              ? // check if more digits
                [N1Start, N2Start] extends ['', '']
                ? // overflow and no more digits
                  Str.Append<'1', string & NewDigit>
                : // more digits and overflow, so add 1
                  Str.Append<Add<Add<N1Start, N2Start>, '1'>, NewDigit & string>
              : // no overflow, simple addition
                Str.Append<Add<N1Start, N2Start>, NewDigit & string>
            : never
          : never
        : never
      : // N2 is empty, return N1
        N1
    : // N1 is empty, return N2
      N2;

/**
 * Given two string digits, returns a tuple of which the first element is the resulting digit from subtracting the second from the first,
 * and the second element a boolean that is true if there is an 'underflow' or borrow, never otherwise.
 * @example
 * ```ts
 * SubDigit<'5', '3'> => ['2', never]
 * SubDigit<'3', '6'> => ['7', true]
 * ```
 */
export type SubDigit<D1 extends Digit, D2 extends Digit> = D2 extends '0'
  ? [D1, false]
  : D1 extends D2
    ? ['0', false]
    : Str.Append<D1, D2> extends infer DD
      ? DD extends '09' | '21' | '32' | '43' | '54' | '65' | '76' | '87' | '98'
        ? ['1', U.Extends<DD, '09'>]
        : DD extends
              | '08'
              | '19'
              | '31'
              | '42'
              | '53'
              | '64'
              | '75'
              | '86'
              | '97'
          ? ['2', U.Extends<DD, '08' | '19'>]
          : DD extends
                | '07'
                | '18'
                | '29'
                | '41'
                | '52'
                | '63'
                | '74'
                | '85'
                | '96'
            ? ['3', U.Extends<DD, '07' | '18' | '29'>]
            : DD extends
                  | '06'
                  | '17'
                  | '28'
                  | '39'
                  | '51'
                  | '62'
                  | '73'
                  | '84'
                  | '95'
              ? ['4', U.Extends<DD, '06' | '17' | '28' | '39'>]
              : DD extends
                    | '05'
                    | '16'
                    | '27'
                    | '38'
                    | '49'
                    | '61'
                    | '72'
                    | '83'
                    | '94'
                ? ['5', U.Extends<DD, '05' | '16' | '27' | '38' | '49'>]
                : DD extends
                      | '04'
                      | '15'
                      | '26'
                      | '37'
                      | '48'
                      | '59'
                      | '71'
                      | '82'
                      | '93'
                  ? [
                      '6',
                      U.Extends<DD, '04' | '15' | '26' | '37' | '48' | '59'>,
                    ]
                  : DD extends
                        | '03'
                        | '14'
                        | '25'
                        | '36'
                        | '47'
                        | '58'
                        | '69'
                        | '81'
                        | '92'
                    ? [
                        '7',
                        U.Extends<
                          DD,
                          '03' | '14' | '25' | '36' | '47' | '58' | '69'
                        >,
                      ]
                    : DD extends
                          | '02'
                          | '13'
                          | '24'
                          | '35'
                          | '46'
                          | '57'
                          | '68'
                          | '79'
                          | '91'
                      ? [
                          '8',
                          U.Extends<
                            DD,
                            | '02'
                            | '13'
                            | '24'
                            | '35'
                            | '46'
                            | '57'
                            | '68'
                            | '79'
                          >,
                        ]
                      : DD extends
                            | '01'
                            | '12'
                            | '23'
                            | '34'
                            | '45'
                            | '56'
                            | '67'
                            | '78'
                            | '89'
                        ? ['9', true]
                        : never
      : never;

/**
 * Returns the result of subtracting the second from the first given string-number,
 * or never if the second value is greater than the first. (Only natural numbers currently supported)
 * @example
 * ```ts
 * SSubtract<'13', '8'> => '5'
 * SSubtract<'5371', '139'> => '5232'
 * SSubtract<'100', '101'> => never
 * ```
 */
export type Subtract<N1 extends string, N2 extends string> = N1 extends N2
  ? // input is equal
    '0'
  : // check if N1 is non-empty
    N1 extends Str.Append<infer N1Start, Digit>
    ? // check if N2 is non-empty
      N2 extends Str.Append<infer N2Start, Digit>
      ? // Retrieve last digit of N1
        N1 extends Str.Append<N1Start, infer N1LastDigit>
        ? // Retrieve last digit of N2
          N2 extends Str.Append<N2Start, infer N2LastDigit>
          ? // Calculate new digit and underflow
            SubDigit<Digit & N1LastDigit, Digit & N2LastDigit> extends [
              infer NewDigit,
              infer Underflow,
            ]
            ? Underflow extends true
              ? // there is underflow, but no more digits to process, would be negative so stop processing
                N1Start extends ''
                ? never
                : // underflow so subtract 1 from the start digits
                  Subtract<Subtract<N1Start, N2Start>, '1'> extends infer Start
                  ? // Number should never start with 0, so skip 0
                    Start extends '0'
                    ? Digit & NewDigit
                    : Str.Append<string & Start, Digit & NewDigit>
                  : never
              : // No underflow, calculate rest (start)
                Subtract<N1Start, N2Start> extends infer Start
                ? // Number should never start with 0, so skip 0
                  Start extends '0'
                  ? Digit & NewDigit
                  : Str.Append<string & Start, Digit & NewDigit>
                : never
            : never
          : never
        : never
      : // N2 is empty, return rest of N1
        N1
    : // N1 is empty, either it is not valid or N2 is larger
      never;

/**
 * Converts a natural number to a string-number, otherwise never.
 * @example
 * ```ts
 * NumberToStringNum<123> => '123'
 * NumberToStringNum<-13> => never
 * ```
 */
export type FromNumber<N extends number> = NatNum<`${N}`>;

/**
 * Infers and returns the length of given Tuple T.
 */
export type TupleLength<T extends unknown[]> = T extends { length: infer L }
  ? L
  : never;

/**
 * A table from StringDigits to an array that repeats the elements of given
 * array T digit amount of times.
 * 'deca' is used to represent an exponent of 10
 */
export type DigitToTup<T extends unknown[] = [unknown]> = {
  '0': [];
  '1': T;
  '2': [...T, ...T];
  '3': [...T, ...T, ...T];
  '4': [...T, ...T, ...T, ...T];
  '5': [...T, ...T, ...T, ...T, ...T];
  '6': [...T, ...T, ...T, ...T, ...T, ...T];
  '7': [...T, ...T, ...T, ...T, ...T, ...T, ...T];
  '8': [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T];
  '9': [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T];
  '10': [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T];
};

/**
 * Builds a tuple of the length of a given string-number. The length can be used
 * to convert a string-number to a number.
 */
export type BuildTuple<N extends string> = BuildTupleHelper<N, []>;

type BuildTupleHelper<N extends string, Result extends unknown[]> =
  N extends Str.Append<Digit & infer D, infer Rest>
    ? BuildTupleHelper<
        Rest,
        [...DigitToTup[Digit & D], ...DigitToTup<Result>['10']]
      >
    : Result;

/**
 * Converts the given string-number to its corresponding number.
 * @note due to compiler limitations the maximum value is '9999'
 * @example
 * ```ts
 * StringNumToNumber<'13'> => 13
 * StringNumToNumber<'5234'> => 5234
 * ```
 */
export type ToNumber<N extends string> = TupleLength<BuildTuple<N>>;

/**
 * Returns the result of multiplying the given string number with the given digit.
 */
export type MultDigit<N1 extends string, D extends Digit> = N1 extends '0'
  ? '0'
  : N1 extends '1'
    ? D
    : D extends '0'
      ? '0'
      : D extends '1'
        ? N1
        : D extends '2'
          ? Add<N1, N1>
          : D extends '3'
            ? Add<N1, Add<N1, N1>>
            : D extends '4'
              ? Add<N1, N1> extends infer T
                ? Add<string & T, string & T>
                : never
              : D extends '5'
                ? Add<N1, MultDigit<N1, '4'>>
                : D extends '6'
                  ? MultDigit<N1, '3'> extends infer T
                    ? Add<string & T, string & T>
                    : never
                  : D extends '7'
                    ? Add<N1, MultDigit<N1, '6'>>
                    : D extends '8'
                      ? MultDigit<N1, '4'> extends infer T
                        ? Add<string & T, string & T>
                        : never
                      : D extends '9'
                        ? Add<N1, MultDigit<N1, '8'>>
                        : never;

export type Mult<N1 extends string, N2 extends string> =
  N2 extends Str.Append<infer N2Start, Digit>
    ? N2Start extends ''
      ? MultDigit<N1, Digit & N2>
      : N2 extends Str.Append<N2Start, infer N2Last>
        ? Add<MultDigit<N1, Digit & N2Last>, Str.Append<Mult<N1, N2Start>, '0'>>
        : never
    : never;

export type AmountTimesIn<
  Small extends string,
  Large extends string,
> = AmountTimesInHelper<Small, Large, '0'>;

type AmountTimesInHelper<
  Small extends string,
  Large extends string,
  Am extends string,
> = Small extends Large
  ? [Add<Am, '1'>, '0']
  : Subtract<Large, Small> extends never
    ? [Am, Large]
    : Subtract<Large, Small> extends infer Result
      ? AmountTimesInHelper<Small, string & Result, Add<Am, '1'>>
      : never;

export type AppendDigit<N extends string, D extends Digit> = N extends '0'
  ? D
  : Str.Append<N, D>;

export type Divide<N extends string, M extends string> = DivideHelper<
  N,
  M,
  '',
  ''
>;

type DivideHelper<
  N extends string,
  M extends string,
  Q extends string,
  R extends string,
> = M extends '0'
  ? never
  : N extends Str.Append<infer Dig, infer Rest>
    ? AppendDigit<R, Digit & Dig> extends infer D
      ? AmountTimesIn<M, string & D> extends [infer B, infer NewR]
        ? DivideHelper<Rest, M, AppendDigit<Q, Digit & B>, string & NewR>
        : never
      : never
    : [Q, R];