import {
    getStdout,
    type ITraceable,
    LogLevel,
    type LogMetricTraceSupplier,
    memoize,
    Metric,
    TraceUtil,
    validateExecutionEntries,
    Either,
    type IEither,
} from '@emprespresso/pengueno';
import type { Job, JobArgT, Pipeline } from '@emprespresso/ci_model';

// -- <job.exectuor> --
const jobTypeMetric = memoize((type: string) => Metric.fromName(`run.${type}`));
export const executeJob = (tJob: ITraceable<Job, LogMetricTraceSupplier>) =>
    tJob
        .bimap(TraceUtil.withMetricTrace(jobTypeMetric(tJob.get().type)))
        .peek((tJob) => tJob.trace.trace(`let's do this little job ok!! ${tJob.get()}`))
        .map((tJob) =>
            validateExecutionEntries(tJob.get().arguments)
                .mapLeft((badEntries) => {
                    tJob.trace.addTrace(LogLevel.ERROR).trace(badEntries.toString());
                    return new Error('invalid job arguments');
                })
                .flatMapAsync((args) => getStdout(tJob.move(tJob.get().type), { env: args })),
        )
        .peek(
            TraceUtil.promiseify((q) =>
                q.trace.trace(
                    q.get().fold(({ isLeft }) => jobTypeMetric(tJob.get().type)[isLeft ? 'failure' : 'success']),
                ),
            ),
        )
        .get();
// -- </job.exectuor> --

// -- <pipeline.executor> --
const pipelinesMetric = Metric.fromName('pipelines');
export const executePipeline = (
    tPipeline: ITraceable<Pipeline, LogMetricTraceSupplier>,
    baseEnv?: JobArgT,
): Promise<IEither<Error, void>> =>
    tPipeline
        .bimap(TraceUtil.withFunctionTrace(executePipeline))
        .bimap(TraceUtil.withMetricTrace(pipelinesMetric))
        .map(async (tJobs): Promise<IEither<Error, void>> => {
            for (const [i, serialStage] of tJobs.get().serialJobs.entries()) {
                tJobs.trace.trace(`executing stage ${i}. do your best little stage :>\n${serialStage}`);
                const jobResults = await Promise.all(
                    serialStage.parallelJobs.map((job) =>
                        tJobs
                            .bimap((_) => [job, `stage ${i}`])
                            .map(
                                (tJob) =>
                                    <Job>{
                                        ...tJob.get(),
                                        arguments: {
                                            ...baseEnv,
                                            ...tJob.get().arguments,
                                        },
                                    },
                            )
                            .map(executeJob)
                            .peek(
                                TraceUtil.promiseify((tEitherJobOutput) =>
                                    tEitherJobOutput
                                        .get()
                                        .mapRight((stdout) => tEitherJobOutput.trace.addTrace('STDOUT').trace(stdout)),
                                ),
                            )
                            .get(),
                    ),
                );
                const failures = jobResults.filter((e) => e.fold(({ isLeft }) => isLeft));
                if (failures.length > 0) {
                    tJobs.trace.trace(pipelinesMetric.failure);
                    return Either.left(new Error(failures.toString()));
                }
            }
            tJobs.trace.trace(pipelinesMetric.success);
            return Either.right(undefined);
        })
        .get();
// -- </pipeline.executor> --