import {
    Either,
    getRequiredEnvVars,
    getStdout,
    type IEither,
    type ITraceable,
    type LogMetricTraceSupplier,
    Metric,
    TraceUtil,
} from "@emprespresso/pengueno";

// -- <ISecret> --
export interface LoginItem {
    login: {
        username: string;
        password: string;
    };
}

export interface SecureNote {
    notes: string;
}

export type SecretItem = LoginItem | SecureNote;
export interface IVault<TClient, TKey, TItemId> {
    unlock: (client: TClient) => Promise<IEither<Error, TKey>>;
    lock: (client: TClient, key: TKey) => Promise<IEither<Error, TKey>>;

    fetchSecret: <T extends SecretItem>(
        client: TClient,
        key: TKey,
        item: TItemId,
    ) => Promise<IEither<Error, T>>;
}
// -- </ISecret> --

// -- <IVault> --
type TClient = ITraceable<unknown, LogMetricTraceSupplier>;
type TKey = string;
type TItemId = string;
export class Bitwarden implements IVault<TClient, TKey, TItemId> {
    constructor(private readonly config: BitwardenConfig) {}

    public unlock(client: TClient) {
        return client
            .move(this.config)
            .bimap(TraceUtil.withMetricTrace(Bitwarden.loginMetric))
            .flatMap((tConfig) =>
                tConfig
                    .move(`bw config server ${tConfig.get().server}`)
                    .map(getStdout),
            )
            .map(async (tEitherWithConfig) => {
                const eitherWithConfig = await tEitherWithConfig.get();
                tEitherWithConfig.trace.trace("logging in~ ^.^");
                return eitherWithConfig.flatMapAsync((_) =>
                    tEitherWithConfig
                        .move("bw login --apikey --quiet")
                        .map(getStdout)
                        .get(),
                );
            })
            .peek(async (tEitherWithAuthd) => {
                const eitherWithAuthd = await tEitherWithAuthd.get();
                return tEitherWithAuthd.trace.trace(
                    eitherWithAuthd.fold(
                        ({ isLeft }) =>
                            Bitwarden.loginMetric[
                                isLeft ? "failure" : "success"
                            ],
                    ),
                );
            })
            .map(async (tEitherWithAuthd) => {
                const eitherWithAuthd = await tEitherWithAuthd.get();
                tEitherWithAuthd.trace.trace(
                    "unlocking the secret vault~ (◕ᴗ◕✿)",
                );
                return eitherWithAuthd.flatMapAsync((_) =>
                    tEitherWithAuthd
                        .move("bw unlock --passwordenv BW_PASSWORD --raw")
                        .map(getStdout)
                        .get(),
                );
            })
            .peek(async (tEitherWithSession) => {
                const eitherWithAuthd = await tEitherWithSession.get();
                return tEitherWithSession.trace.trace(
                    eitherWithAuthd.fold(
                        ({ isLeft }) =>
                            Bitwarden.unlockVaultMetric[
                                isLeft ? "failure" : "success"
                            ],
                    ),
                );
            })
            .get();
    }

    public fetchSecret<T extends SecretItem>(
        client: TClient,
        key: string,
        item: string,
    ): Promise<IEither<Error, T>> {
        return client
            .move(key)
            .bimap(TraceUtil.withMetricTrace(Bitwarden.fetchSecretMetric))
            .peek((tSession) =>
                tSession.trace.trace(`looking for your secret ${item} (⑅˘꒳˘)`),
            )
            .flatMap((tSession) =>
                tSession
                    .move("bw list items")
                    .map((listCmd) =>
                        getStdout(listCmd, {
                            env: { BW_SESSION: tSession.get() },
                        }),
                    ),
            )
            .map(
                TraceUtil.promiseify((tEitherItemsJson) =>
                    tEitherItemsJson
                        .get()
                        .flatMap(
                            (
                                itemsJson,
                            ): IEither<Error, Array<T & { name: string }>> =>
                                Either.fromFailable(() =>
                                    JSON.parse(itemsJson),
                                ),
                        )
                        .flatMap((itemsList): IEither<Error, T> => {
                            const secret = itemsList.find(
                                ({ name }) => name === item,
                            );
                            if (!secret) {
                                return Either.left(
                                    new Error(
                                        `couldn't find the item ${item} (｡•́︿•̀｡)`,
                                    ),
                                );
                            }
                            return Either.right(secret);
                        }),
                ),
            )
            .peek(async (tEitherWithSecret) => {
                const eitherWithSecret = await tEitherWithSecret.get();
                return tEitherWithSecret.trace.trace(
                    eitherWithSecret.fold(
                        ({ isLeft }) =>
                            Bitwarden.fetchSecretMetric[
                                isLeft ? "failure" : "success"
                            ],
                    ),
                );
            })
            .get();
    }

    public lock(client: TClient, key: TKey) {
        return client
            .move(key)
            .bimap(TraceUtil.withMetricTrace(Bitwarden.lockVaultMetric))
            .peek((tSession) =>
                tSession.trace.trace(`taking care of locking the vault :3`),
            )
            .flatMap((tSession) =>
                tSession
                    .move("bw lock")
                    .map((lockCmd) =>
                        getStdout(lockCmd, {
                            env: { BW_SESSION: tSession.get() },
                        }),
                    ),
            )
            .peek(async (tEitherWithLocked) => {
                const eitherWithLocked = await tEitherWithLocked.get();
                return eitherWithLocked.fold(({ isLeft }) => {
                    tEitherWithLocked.trace.trace(
                        Bitwarden.lockVaultMetric[isLeft ? "failure" : "success"],
                    );
                    if (isLeft) return;
                    tEitherWithLocked.trace.trace(
                        "all locked up and secure now~ (｡•̀ᴗ-)✧",
                    );
                });
            })
            .get();
    }

    public static getConfigFromEnvironment(): IEither<Error, BitwardenConfig> {
        return getRequiredEnvVars([
            "BW_SERVER",
            "BW_CLIENTSECRET",
            "BW_CLIENTID",
            "BW_PASSWORD",
        ]).mapRight(({ BW_SERVER, BW_CLIENTSECRET, BW_CLIENTID }) => ({
            clientId: BW_CLIENTID,
            secret: BW_CLIENTSECRET,
            server: BW_SERVER,
        }));
    }

    private static loginMetric = Metric.fromName("Bitwarden.login");
    private static unlockVaultMetric = Metric.fromName("Bitwarden.unlockVault");
    private static fetchSecretMetric = Metric.fromName("Bitwarden.fetchSecret");
    private static lockVaultMetric = Metric.fromName("Bitwarden.lock");
}

export interface BitwardenConfig {
    server: string;
    secret: string;
    clientId: string;
}
// -- </IVault> --