import { AbstractClass, Class, Simplify } from "type-fest"
import { Trait, TraitTuple } from "./Trait"
import { TraitBuilder } from "./TraitBuilder"
import { Extend, StaticMembers } from "./util"


export class TraitExpression<
    Superclass   extends AbstractClass<object>,
    const Traits extends readonly Trait<any, any, any, any>[],
> {
    constructor(
        readonly superclass:  Superclass,
        readonly traits:      Traits,
    ) {}


    get extends(): (
        AbstractClass<
            InstanceType<Superclass> &  // Keep the instance of the superclass outside of any kind of type manipulation
                                        // as it can accidentely remove abstract properties
            Simplify<
                Extend<TraitTuple.MapImplInstance<Traits>>
            >,

            ConstructorParameters<Superclass>
        > &

        Simplify<
            Extend<[
                StaticMembers<Superclass>,
                ...TraitTuple.MapImplStaticMembers<Traits>,
            ]>
        >
    ) {
        return this.traits.reduce(
            (previous, trait) => trait.apply(previous),
            this.superclass,
        ) as any
    }


    staticImplements(_target: StaticImplements<typeof this>, _context: any) {}

    get staticImplementsStage2() {
        return (_target: StaticImplements<typeof this>) => {}
    }


    subtrait<
        This extends TraitExpression<typeof TraitExpression.NullSuperclass, any>
    >(
        this: This
    ) {
        return new TraitBuilder<This,
            Simplify<
                Extend<TraitTuple.MapAbstract<Traits>>
            >,
            Simplify<
                Extend<TraitTuple.MapStaticAbstract<Traits>>
            >,

            AbstractClass<
                Simplify<
                    Extend<TraitTuple.MapImplInstance<Traits>>
                >
            > &
            Simplify<
                Extend<TraitTuple.MapImplStaticMembers<Traits>>
            >
        >(
            this,
            {} as any,
            {} as any,
            Super => class extends Super {} as any,
        )
    }
}

export namespace TraitExpression {
    const nullSuperclassSymbol = Symbol()
    export class NullSuperclass {
        static readonly [nullSuperclassSymbol]: true
        constructor(..._args: any[]) {}
    }

    export type Superclass<T> = (
        T extends TraitExpression<infer Superclass, any>
            ? Superclass
            : never
    )

    export type Traits<T> = (
        T extends TraitExpression<any, infer Traits>
            ? Traits
            : never
    )
}


export type Implements<
    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
> = (
    Simplify<
        Extend<
            TraitTuple.MapAbstract<
                TraitExpression.Traits<Exp>
            >
        >
    >
)

export type StaticImplements<
    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
> = (
    Simplify<
        Extend<
            TraitTuple.MapStaticAbstract<
                TraitExpression.Traits<Exp>
            >
        >
    >
)


export type TraitExpressionClass<
    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
> = (
    AbstractClass<
        TraitExpressionInstance<Exp>,
        ConstructorParameters<TraitExpression.Superclass<Exp>>
    > &
    TraitExpressionStaticMembers<Exp>
)

export type TraitExpressionConcreteClass<
    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
> = (
    Class<
        TraitExpressionInstance<Exp>,
        ConstructorParameters<TraitExpression.Superclass<Exp>>
    > &
    TraitExpressionStaticMembers<Exp>
)

export type TraitExpressionInstance<
    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
> = (
    InstanceType<TraitExpression.Superclass<Exp>> &  // Keep the instance of the superclass outside of any kind of type manipulation
                                                     // as it can accidentely remove abstract properties
    Simplify<
        Extend<
            TraitTuple.MapInstance<TraitExpression.Traits<Exp>>
        >
    >
)

export type TraitExpressionStaticMembers<
    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
> = (
    Simplify<
        Extend<[
            StaticMembers<TraitExpression.Superclass<Exp>>,
            ...TraitTuple.MapStaticMembers<TraitExpression.Traits<Exp>>,
        ]>
    >
)