import { Call, Fn, Pipe, Tuples } from "hotscript"
import { AbstractClass } from "type-fest"
import { Trait } from "./Trait"
import { TraitExpression, emptyTraitExpression } from "./TraitExpression"
import { ExtendableFn, StaticMembersFn } from "./util"


type SpreadSupertraits<Traits extends Trait<any, any, any, any>[]> = (
    Call<
        Tuples.FlatMap<PrependTraitSupertraitsFn>,
        Traits
    >
)
interface PrependTraitSupertraitsFn extends Fn {
    return: [...Trait.Supertraits<this["arg0"]>, this["arg0"]]
}


type AbstractMembersExtendable<
    Superclass extends AbstractClass<{}>,
    Traits     extends Trait<any, any, any, any>[],
> = (
    Pipe<Traits, [
        Tuples.Map<Trait.OwnAbstractFn>,
        Tuples.Prepend<InstanceType<Superclass>>,
    ]>
)

type ImplInstanceExtendable<
    Superclass extends AbstractClass<{}>,
    Traits     extends Trait<any, any, any, any>[],
> = (
    Pipe<Traits, [
        Tuples.Map<Trait.OwnImplInstanceFn>,
        Tuples.Prepend<InstanceType<Superclass>>,
    ]>
)

type ImplStaticMembersExtendable<
    Superclass extends AbstractClass<{}>,
    Traits     extends Trait<any, any, any, any>[],
> = (
    Pipe<Traits, [
        Tuples.Map<Trait.OwnImplClassFn>,
        Tuples.Prepend<Superclass>,
        Tuples.Map<StaticMembersFn>,
        ExtendableFn,
    ]>
)

type BuildTraitExpression<
    Superclass extends AbstractClass<{}>,
    OwnTraits  extends Trait<any, any, any, any>[],
    AllTraits  extends Trait<any, any, any, any>[],
> = (
    AbstractMembersExtendable<Superclass, AllTraits> extends false
        ? "Type conflict between the traits abstract members and/or the superclass instance."
        : ImplInstanceExtendable<Superclass, AllTraits> extends false
            ? "Type conflict between the traits implementation instances and/or the superclass instance."
            : ImplStaticMembersExtendable<Superclass, AllTraits> extends false
                ? "Type conflict between the traits implementation static members and/or the superclass static members."
                : TraitExpression<Superclass, OwnTraits, AllTraits>
)


class TraitExpressionBuilder<
    Superclass      extends AbstractClass<{}>,
    const OwnTraits extends Trait<any, any, any, any>[],
    const AllTraits extends Trait<any, any, any, any>[],
> {
    constructor(private expression: TraitExpression<Superclass, OwnTraits, AllTraits>) {}

    extends<
        Super extends AbstractClass<any>
    >(
        superclass: Super
    ) {
        return new TraitExpressionBuilder(
            new TraitExpression(
                superclass,
                this.expression.ownTraits,
                this.expression.allTraits,
            )
        )
    }

    expresses<
        const Traits extends Trait<any, any, any, any>[]
    >(
        ...traits: Traits
    ): TraitExpressionBuilder<
        Superclass,
        [...OwnTraits, ...Traits],
        [...AllTraits, ...SpreadSupertraits<Traits>]
    > {
        return new TraitExpressionBuilder(
            new TraitExpression(
                this.expression.superclass,
                [...this.expression.ownTraits, ...traits],
                [...this.expression.allTraits, ...this.spreadSupertraits(traits)],
            )
        )
    }

    private spreadSupertraits<
        const Traits extends Trait<
            TraitExpression<any, any, Trait<any, any, any, any>[]>,
            any,
            any,
            any
        >[]
    >(
        traits: Traits
    ) {
        return traits.flatMap(trait => [
            ...trait.supertraits.allTraits,
            trait,
        ]) as SpreadSupertraits<Traits>
    }

    build() {
        return this.expression as BuildTraitExpression<Superclass, OwnTraits, AllTraits>
    }

    then<V>(fn: (expression: ReturnType<typeof this.build>) => V): V {
        return fn(this.build())
    }
}

export const expression = new TraitExpressionBuilder(emptyTraitExpression)