import { Trait, TraitExpressionBuilder, expression } from "@thilawyn/traitify-ts"
import { AbstractClass, Simplify } from "type-fest"
import { z } from "zod"
import { ExtendableZodSchemaObject } from "./traits/ExtendableZodSchemaObject"
import { InstantiableZodSchemaObject } from "./traits/InstantiableZodSchemaObject"
import { Extend, StaticMembers } from "./util"


export class ZodSchemaClassBuilder<
    Superclass   extends AbstractClass<object>,
    const Traits extends Trait<any, any, any, any>[],
>
extends TraitExpressionBuilder<Superclass, Traits> {
    // extends<
    //     This  extends ZodSchemaClassBuilder<
    //         typeof TraitExpression.NullSuperclass,  // Ensures `extends` can only be called when the expression does not have a superclass
    //         Traits
    //     >,
    //     Super extends AbstractClass<object, []>,
    // >(
    //     this:        This,
    //     superclass:  Super,
    // ) {
    //     return new ZodSchemaClassBuilder(
    //         this.expressionBuilder.extends(superclass)
    //     )
    // }

    schema<
        Superclass        extends AbstractClass<object> & { schema?: never, defaultValues?: never },

        SchemaT           extends z.ZodRawShape,
        SchemaUnknownKeys extends z.UnknownKeysParam,
        SchemaCatchall    extends z.ZodTypeAny,

        Values            extends object,
        DefaultValues     extends Partial<Values>,
    >(
        this:           ZodSchemaClassBuilder<Superclass, Traits>,
        schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
        defaultValues:  DefaultValues,
    ) {
        class Schemas extends (this.expressionSuperclass as AbstractClass<object, []>) {
            static readonly schema        = schema
            static readonly defaultValues = defaultValues

            constructor(values: Values) {
                super()
                Object.assign(this, values)
            }
        }

        return new ZodSchemaClassBuilder(
            Schemas as unknown as (
                AbstractClass<
                    InstanceType<Superclass> &
                    Simplify<
                        Extend<[Schemas, Values]>
                    >,

                    ConstructorParameters<typeof Schemas>
                > &
                Simplify<
                    Extend<[
                        StaticMembers<Superclass>,
                        StaticMembers<typeof Schemas>,
                    ]>
                >
            ),

            [
                ...this.expressionTraits,
                InstantiableZodSchemaObject,
                ExtendableZodSchemaObject,
            ],
        )
    }

    jsonifiable() {

    }
}


export function ZodSchemaClassOf<
    Superclass        extends AbstractClass<object, []>,

    SchemaT           extends z.ZodRawShape,
    SchemaUnknownKeys extends z.UnknownKeysParam,
    SchemaCatchall    extends z.ZodTypeAny,

    Values            extends object,
    DefaultValues     extends Partial<Values>,
>(
    of: Superclass,

    { schema, defaultValues }: {
        schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
        defaultValues:  DefaultValues
    },
) {
    class Schemas extends (of as AbstractClass<object, []>) {
        static readonly schema        = schema
        static readonly defaultValues = defaultValues

        constructor(values: Values) {
            super()
            Object.assign(this, values)
        }
    }

    return expression
        .extends(Schemas as unknown as (
            AbstractClass<
                InstanceType<Superclass> &
                Simplify<
                    Extend<[Schemas, Values]>
                >,

                ConstructorParameters<typeof Schemas>
            > &
            Simplify<
                Extend<[
                    StaticMembers<Superclass>,
                    StaticMembers<typeof Schemas>,
                ]>
            >
        ))
        .expresses(
            InstantiableZodSchemaObject,
            ExtendableZodSchemaObject,
        )
}


class DefaultRoot {}

export function ZodSchemaClass<
    SchemaT           extends z.ZodRawShape,
    SchemaUnknownKeys extends z.UnknownKeysParam,
    SchemaCatchall    extends z.ZodTypeAny,

    Values            extends object,
    DefaultValues     extends Partial<Values>,
>(
    props: {
        schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
        defaultValues:  DefaultValues
    },
) {
    return ZodSchemaClassOf(DefaultRoot, props)
}