import {
    BiMapper,
    IOptional,
    type Mapper,
    Optional,
    Predicate,
    type Supplier,
    Tagged,
    isTagged,
} from '@emprespresso/pengueno';

export const IEitherTag = 'IEither' as const;
export type IEitherTag = typeof IEitherTag;
export const isEither = <E, T>(o: unknown): o is IEither<E, T> => isTagged(o, IEitherTag);
export interface IEither<E, T> extends Tagged<IEitherTag> {
    readonly left: Supplier<IOptional<E>>;
    readonly right: Supplier<IOptional<T>>;

    readonly mapRight: <_T>(mapper: Mapper<T, _T>) => IEither<E, _T>;
    readonly filter: (mapper: Predicate<T>) => IEither<E, T>;
    readonly mapLeft: <_E>(mapper: Mapper<E, _E>) => IEither<_E, T>;
    readonly mapBoth: <_E, _T>(errBranch: Mapper<E, _E>, okBranch: Mapper<T, _T>) => IEither<_E, _T>;

    readonly flatMap: <_T>(mapper: Mapper<T, IEither<E, _T>>) => IEither<E, _T>;
    readonly flatMapAsync: <_T>(mapper: Mapper<T, Promise<IEither<E, _T>>>) => Promise<IEither<E, _T>>;

    readonly moveRight: <_T>(t: _T) => IEither<E, _T>;
    readonly fold: <_T>(leftFolder: Mapper<E, _T>, rightFolder: Mapper<T, _T>) => _T;
    readonly joinRight: <O, _T>(other: IEither<E, O>, mapper: BiMapper<O, T, _T>) => IEither<E, _T>;
    readonly joinRightAsync: <O, _T>(
        other: Supplier<Promise<IEither<E, O>>> | Promise<IEither<E, O>>,
        mapper: BiMapper<O, T, _T>,
    ) => Promise<IEither<E, _T>>;
}

const ELeftTag = 'E.Left' as const;
type ELeftTag = typeof ELeftTag;
export const isLeft = <E>(o: unknown): o is Left<E> => isTagged(o, ELeftTag);
interface Left<E> extends Tagged<ELeftTag> {
    err: E;
}

const ERightTag = 'E.Right' as const;
type ERightTag = typeof ERightTag;
export const isRight = <T>(o: unknown): o is Right<T> => isTagged(o, ERightTag);
interface Right<T> extends Tagged<ERightTag> {
    ok: T;
}

class _Tagged implements Tagged<IEitherTag> {
    protected constructor(public readonly _tag = IEitherTag) {}
}

export class Either<E, T> extends _Tagged implements IEither<E, T> {
    protected constructor(private readonly self: Left<E> | Right<T>) {
        super();
    }

    public moveRight<_T>(t: _T) {
        return this.mapRight(() => t);
    }

    public mapBoth<_E, _T>(errBranch: Mapper<E, _E>, okBranch: Mapper<T, _T>): IEither<_E, _T> {
        if (isLeft(this.self)) return Either.left(errBranch(this.self.err));
        return Either.right(okBranch(this.self.ok));
    }

    public mapRight<_T>(mapper: Mapper<T, _T>): IEither<E, _T> {
        if (isRight(this.self)) return Either.right(mapper(this.self.ok));
        return Either.left(this.self.err);
    }

    public mapLeft<_E>(mapper: Mapper<E, _E>): IEither<_E, T> {
        if (isLeft(this.self)) return Either.left(mapper(this.self.err));
        return Either.right(this.self.ok);
    }

    public flatMap<_T>(mapper: Mapper<T, IEither<E, _T>>): IEither<E, _T> {
        if (isRight(this.self)) return mapper(this.self.ok);
        return Either.left<E, _T>(this.self.err);
    }

    public filter(mapper: Predicate<T>): IEither<E, T> {
        if (isLeft(this.self)) return Either.left<E, T>(this.self.err);
        return Either.fromFailable<E, T>(() => this.right().filter(mapper).get());
    }

    public async flatMapAsync<_T>(mapper: Mapper<T, Promise<IEither<E, _T>>>): Promise<IEither<E, _T>> {
        if (isLeft(this.self)) return Promise.resolve(Either.left(this.self.err));
        return await mapper(this.self.ok).catch((err) => Either.left(err));
    }

    public fold<_T>(leftFolder: Mapper<E, _T>, rightFolder: Mapper<T, _T>): _T {
        if (isLeft(this.self)) return leftFolder(this.self.err);
        return rightFolder(this.self.ok);
    }

    public left(): IOptional<E> {
        if (isLeft(this.self)) return Optional.from(this.self.err) as IOptional<E>;
        return Optional.none();
    }

    public right(): IOptional<T> {
        if (isRight(this.self)) return Optional.from(this.self.ok) as IOptional<T>;
        return Optional.none();
    }

    public joinRight<O, _T>(other: IEither<E, O>, mapper: BiMapper<O, T, _T>) {
        return this.flatMap((t) => other.mapRight((o) => mapper(o, t)));
    }

    public joinRightAsync<O, _T>(
        other: Supplier<Promise<IEither<E, O>>> | Promise<IEither<E, O>>,
        mapper: BiMapper<O, T, _T>,
    ) {
        return this.flatMapAsync(async (t) => {
            const o = typeof other === 'function' ? other() : other;
            return o.then((other) => other.mapRight((o) => mapper(o, t)));
        });
    }

    static left<E, T>(e: E): IEither<E, T> {
        return new Either({ err: e, _tag: ELeftTag });
    }

    static right<E, T>(t: T): IEither<E, T> {
        return new Either({ ok: t, _tag: ERightTag });
    }

    static fromFailable<E, T>(s: Supplier<T>): IEither<E, T> {
        try {
            return Either.right(s());
        } catch (e) {
            return Either.left(e as E);
        }
    }

    static async fromFailableAsync<E, T>(s: Supplier<Promise<T>> | Promise<T>): Promise<IEither<E, T>> {
        return await (typeof s === 'function' ? s() : s)
            .then((t: T) => Either.right<E, T>(t))
            .catch((e: E) => Either.left<E, T>(e));
    }
}