import { TraitExpression, 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<
    Exp extends TraitExpressionBuilder<any, any>
> {
    constructor(
        private readonly expressionBuilder: Exp
    ) {}

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

    schema<
        This extends ZodSchemaClassBuilder<
            TraitExpressionBuilder<
                any,
                any
            >
        >,

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

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

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

        return new ZodSchemaClassBuilder(
            this.expressionBuilder
                .extends()
                .expresses(
                    InstantiableZodSchemaObject,
                    ExtendableZodSchemaObject,
                )
        )
    }

    jsonifiable() {

    }

    toBuilder() {
        return this.expressionBuilder
    }
}


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)
}