import { FfmpegCommand } from '@ownzones/fluent-ffmpeg';
import { RequestPromise } from 'requestretry';

export type Nullable<T> = T | null;

export type ReadonlyTupleToUnionType<T extends readonly any[]> = T[number];

export type NestedObject<T> = {
  [key: string]: T | NestedObject<T>
};

export type TrackedFFmpegCommand = {
  ffmpegCommand: FfmpegCommand,
  ffmpegPromise: Promise<void>
};

export type TaskResponses<TSegment> = Record<string, TaskResponse<TSegment>>;
export type TaskResponse<TSegment> = TaskResponseResult<TSegment & { s3Path: string, size: number }> | TaskResponseError;
type TaskResponseResult<TResult> = { error: false, result: TResult };
type TaskResponseError = { error: true, errorObject: Error };

export function hasOwnProperty<TObj, TProp extends keyof any>(obj: TObj, property: TProp) : obj is TObj & Record<TProp, unknown> {
  return Object.prototype.hasOwnProperty.call(obj, property);
}

export function isInTuple<TElem, TTuple extends readonly any[]>(elem: TElem, tuple: TTuple): elem is ReadonlyTupleToUnionType<TTuple> {
  return !!elem && (tuple).includes(elem);
}

export type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends Array<infer U>
    ? Array<DeepPartial<U>>
    : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : DeepPartial<T[P]>
};

export interface GenericRequestPromise<TThen, TCatch> extends RequestPromise {
  then: Promise<TThen>['then'];
  catch: Promise<TCatch>['catch'];
}