import type { Mapper, SideEffect, Supplier } from '@emprespresso/pengueno';

// the "thing" every Trace writer must "trace()"
type BaseTraceWith = string;
export type ITraceWith<T> = BaseTraceWith | T;
export interface ITrace<TraceWith> {
    addTrace: Mapper<ITraceWith<TraceWith>, ITrace<TraceWith>>;
    trace: SideEffect<ITraceWith<TraceWith>>;
}

export type ITraceableTuple<T, TraceWith> = [T, BaseTraceWith | TraceWith];
export type ITraceableMapper<T, _T, TraceWith, W = ITraceable<T, TraceWith>> = (w: W) => _T;

export interface ITraceable<T, Trace = BaseTraceWith> {
    readonly trace: ITrace<Trace>;
    get: Supplier<T>;
    move: <_T>(t: _T) => ITraceable<_T, Trace>;
    map: <_T>(mapper: ITraceableMapper<T, _T, Trace>) => ITraceable<_T, Trace>;
    bimap: <_T>(mapper: ITraceableMapper<T, ITraceableTuple<_T, Array<Trace> | Trace>, Trace>) => ITraceable<_T, Trace>;
    peek: (peek: ITraceableMapper<T, void, Trace>) => ITraceable<T, Trace>;
    flatMap: <_T>(mapper: ITraceableMapper<T, ITraceable<_T, Trace>, Trace>) => ITraceable<_T, Trace>;
    flatMapAsync<_T>(
        mapper: ITraceableMapper<T, Promise<ITraceable<_T, Trace>>, Trace>,
    ): ITraceable<Promise<_T>, Trace>;
}

export class TraceableImpl<T, TraceWith> implements ITraceable<T, TraceWith> {
    protected constructor(
        private readonly item: T,
        public readonly trace: ITrace<TraceWith>,
    ) {}

    public map<_T>(mapper: ITraceableMapper<T, _T, TraceWith>) {
        const result = mapper(this);
        return new TraceableImpl(result, this.trace);
    }

    public flatMap<_T>(mapper: ITraceableMapper<T, ITraceable<_T, TraceWith>, TraceWith>): ITraceable<_T, TraceWith> {
        return mapper(this);
    }

    public flatMapAsync<_T>(
        mapper: ITraceableMapper<T, Promise<ITraceable<_T, TraceWith>>, TraceWith>,
    ): ITraceable<Promise<_T>, TraceWith> {
        return new TraceableImpl(
            mapper(this).then((t) => t.get()),
            this.trace,
        );
    }

    public peek(peek: ITraceableMapper<T, void, TraceWith>) {
        peek(this);
        return this;
    }

    public move<_T>(t: _T): ITraceable<_T, TraceWith> {
        return this.map(() => t);
    }

    public bimap<_T>(mapper: ITraceableMapper<T, ITraceableTuple<_T, Array<TraceWith> | TraceWith>, TraceWith>) {
        const [item, trace] = mapper(this);
        const traces = Array.isArray(trace) ? trace : [trace];
        return new TraceableImpl(
            item,
            traces.reduce((trace, _trace) => trace.addTrace(_trace), this.trace),
        );
    }

    public get() {
        return this.item;
    }
}