import { IOptional, Either, Optional, type IEither } from '@emprespresso/pengueno';

export const getEnv = <V extends string>(name: string): IOptional<V> =>
    Optional.from(<V>process.env[name]).filter((val) => val.trim() !== '');

export const getRequiredEnv = <V extends string>(name: string): IEither<Error, V> =>
    getEnv<V>(name)
        .map((envVal) => Either.right<Error, V>(<V>envVal))
        .orSome(() => Either.left<Error, V>(new Error(`environment variable "${name}" is required D:`)))
        .get();

type ObjectFromList<T extends ReadonlyArray<string>, V = string> = {
    [K in T extends ReadonlyArray<infer U> ? U : never]: V;
};

export const getRequiredEnvVars = <V extends string>(vars: ReadonlyArray<V>) =>
    vars
        .map((envVar) => [envVar, getRequiredEnv(envVar)] as [V, IEither<Error, V>])
        .reduce(
            (acc: IEither<Error, ObjectFromList<typeof vars>>, x: [V, IEither<Error, V>]) => {
                const [envVar, eitherVal] = x;
                return acc.flatMap((args) => {
                    return eitherVal.mapRight(
                        (envValue) =>
                            ({
                                ...args,
                                [envVar]: envValue,
                            }) as ObjectFromList<typeof vars>,
                    );
                });
            },
            Either.right({} as ObjectFromList<typeof vars>),
        );