import type { PreviousCell } from './cell-staleness';

export type StepProgramDatasetOptions = {
  runIf?: (
    row: Record<string, unknown>,
    index: number,
  ) => boolean | Promise<boolean>;
  recompute?: boolean;
  recomputeOnError?: boolean;
  staleAfterSeconds?: number;
};

export type StepProgramDatasetColumnRunInput<Value = unknown> = {
  row: Record<string, unknown>;
  ctx: unknown;
  index: number;
  previousCell?: PreviousCell<Value>;
};

export type StepProgramDatasetColumnDefinition<Value = unknown> =
  StepProgramDatasetOptions & {
    run: (
      input: StepProgramDatasetColumnRunInput<Value>,
    ) => Value | Promise<Value>;
  };

export type StepProgramDatasetColumnInput<TResolver> =
  | TResolver
  | StepProgramDatasetColumnDefinition;

function isStepProgramDatasetColumnDefinition(
  value: unknown,
): value is StepProgramDatasetColumnDefinition {
  return (
    value !== null &&
    typeof value === 'object' &&
    typeof (value as { run?: unknown }).run === 'function'
  );
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return value !== null && typeof value === 'object' && !Array.isArray(value);
}

function isPreviousCell(value: unknown): value is PreviousCell {
  return (
    isRecord(value) && Object.prototype.hasOwnProperty.call(value, 'value')
  );
}

export type StepProgramDatasetStep<TResolver> = {
  name: string;
  resolver: TResolver;
};

export type StepProgramDatasetProgram<TStep> = {
  kind: 'steps';
  steps: readonly TStep[];
  continueOnProviderUnavailable?: boolean;
};

export type StepProgramDatasetConditionalResolver<TResolver> = {
  kind: 'conditional';
  when: (
    row: Record<string, unknown>,
    index: number,
  ) => boolean | Promise<boolean>;
  run: TResolver;
  elseValue?: unknown;
};

export function isStepProgramDatasetProgram<TStep>(
  value: unknown,
): value is StepProgramDatasetProgram<TStep> {
  return (
    value !== null &&
    typeof value === 'object' &&
    (value as { kind?: unknown }).kind === 'steps' &&
    Array.isArray((value as { steps?: unknown }).steps)
  );
}

export function isStepProgramDatasetConditionalResolver<TResolver>(
  value: unknown,
): value is StepProgramDatasetConditionalResolver<TResolver> {
  return (
    value !== null &&
    typeof value === 'object' &&
    (value as { kind?: unknown }).kind === 'conditional' &&
    typeof (value as { when?: unknown }).when === 'function' &&
    typeof (value as { run?: unknown }).run === 'function'
  );
}

function continuesOnProviderUnavailable<TStep>(
  program: StepProgramDatasetProgram<TStep>,
): boolean {
  return (
    program.continueOnProviderUnavailable === true ||
    program.steps.some(
      (step) =>
        isStepProgramDatasetConditionalResolver(
          (step as StepProgramDatasetStep<unknown>).resolver,
        ) &&
        (
          (
            step as StepProgramDatasetStep<
              StepProgramDatasetConditionalResolver<unknown>
            >
          ).resolver.when as {
            __deeplineProviderWaterfall?: unknown;
          }
        ).__deeplineProviderWaterfall === true,
    )
  );
}

export class StepProgramDatasetBuilder<
  TStep extends StepProgramDatasetStep<TResolver>,
  TResolver,
  TRunOptions,
  TResult,
> {
  private readonly program: StepProgramDatasetProgram<TStep> = {
    kind: 'steps',
    steps: [],
  };

  constructor(
    private readonly runProgram: (
      program: StepProgramDatasetProgram<TStep>,
      options?: TRunOptions,
    ) => TResult,
    private readonly messages: {
      emptyColumnName: string;
      invalidColumnsProgram: string;
      legacyStep: string;
    },
  ) {}

  withColumn(
    name: string,
    columnInput: StepProgramDatasetColumnInput<TResolver>,
    options?: StepProgramDatasetOptions,
  ): this {
    if (!name.trim()) {
      throw new Error(this.messages.emptyColumnName);
    }
    const normalized = this.normalizeColumnInput(columnInput, options);
    this.program.steps = [
      ...this.program.steps,
      {
        name,
        ...(normalized.options?.recompute === true ? { recompute: true } : {}),
        ...(normalized.options?.recomputeOnError === true
          ? { recomputeOnError: true }
          : {}),
        ...(typeof normalized.options?.staleAfterSeconds === 'number'
          ? { staleAfterSeconds: normalized.options.staleAfterSeconds }
          : {}),
        resolver: this.applyDerivationOptions(
          normalized.resolver,
          normalized.options,
        ),
      } as TStep,
    ];
    return this;
  }

  withColumns(program: StepProgramDatasetProgram<TStep>): this {
    if (!isStepProgramDatasetProgram<TStep>(program)) {
      throw new Error(this.messages.invalidColumnsProgram);
    }
    const continueOnProviderUnavailable =
      continuesOnProviderUnavailable(program);
    this.program.steps = [
      ...this.program.steps,
      ...program.steps.map((step) =>
        continueOnProviderUnavailable
          ? ({ ...step, continueOnProviderUnavailable: true } as TStep)
          : step,
      ),
    ];
    return this;
  }

  step(): never {
    throw new Error(this.messages.legacyStep);
  }

  run(options?: TRunOptions): TResult {
    return this.runProgram(this.program, options);
  }

  private applyDerivationOptions(
    resolver: TResolver,
    options?: StepProgramDatasetOptions,
  ): TResolver {
    if (
      !options?.runIf ||
      isStepProgramDatasetConditionalResolver<TResolver>(resolver)
    ) {
      return resolver;
    }
    return {
      kind: 'conditional',
      when: options.runIf,
      run: resolver,
      elseValue: null,
    } as TResolver;
  }

  private normalizeColumnInput(
    columnInput: StepProgramDatasetColumnInput<TResolver>,
    options?: StepProgramDatasetOptions,
  ): { resolver: TResolver; options?: StepProgramDatasetOptions } {
    if (!isStepProgramDatasetColumnDefinition(columnInput)) {
      return { resolver: columnInput, options };
    }

    const { run, ...definitionOptions } = columnInput;
    const resolver = ((
      row: Record<string, unknown>,
      ctx: unknown,
      third?: unknown,
      fourth?: unknown,
      fifth?: unknown,
    ) => {
      const index =
        typeof third === 'number'
          ? third
          : typeof fourth === 'number'
            ? fourth
            : 0;
      const rowForRun =
        isRecord(third) && typeof fourth === 'number' ? third : row;
      const previousCell = isPreviousCell(fifth)
        ? fifth
        : isPreviousCell(fourth)
          ? fourth
          : undefined;
      return run({
        row: rowForRun,
        ctx,
        index,
        ...(previousCell ? { previousCell } : {}),
      });
    }) as TResolver;

    return {
      resolver,
      options: {
        ...definitionOptions,
        ...(options ?? {}),
      },
    };
  }
}