import {z, ZodObject} from "zod";
import {ZodRawShape} from "zod/lib/types";
import {Identifiable} from "../identifiable";

export const UnsafeEntitySymbol: symbol = Symbol("MyType");

export const EntitySymbol: symbol = Symbol("SafeEntity");

export type EntityCore = Identifiable & {
    createdAt: Date,
    updatedAt: Date,
}
export const EntityCoreShape = {
    id: z.string(),
    createdAt: z.coerce.date(),
    updatedAt: z.coerce.date(),
};

export type EntityCoreShapeType = typeof EntityCoreShape

type EntityFn<P, E> = {
    copy: (fields: Partial<P & EntityCore>) => Zentity<P, E>,
    toPlain: () => P & EntityCore
}

type NonBrandedEntity<P, E> = EntityCore & P & EntityFn<P, E> & E

export type UnsafeZentity<P, E> = NonBrandedEntity<P, E> & {
    _brand: typeof UnsafeEntitySymbol,
    validate: () => Zentity<P, E>
}

export type Zentity<P, E> = UnsafeZentity<P, E> & {
    _safe: typeof EntitySymbol
}

export function isZentity(data: any): data is Zentity<any, any> {
    return data?.['_safe'] === EntitySymbol
}


export type EntityClass<S extends ZodRawShape, R> = {
    name: string,
    create: (params: ZodShapeType<S> & EntityCore) => Zentity<ZodShapeType<S>, R>,
    new: (params: ZodShapeType<S> & { id: string }) => Zentity<ZodShapeType<S>, R>,
    unsafe: (params: ZodShapeType<S> & EntityCore) => UnsafeZentity<ZodShapeType<S>, R>,
    schema: ZodObject<S & EntityCoreShapeType>,
    shape: S & EntityCoreShapeType,
    extend: (e: EntityCore & ZodShapeType<S>) => R,
}

export type inferPlainTypeFromClass<E> = E extends EntityClass<infer S, infer R> ? ZodShapeType<S> & EntityCore : never

export type inferZentityTypeFromClass<E> = E extends EntityClass<infer S, infer R> ? Zentity<ZodShapeType<S>, R> : never

export type inferZentityType<E> = E extends EntityClass<infer S, infer R> ? ZodShapeType<S> & R : never

type inferUnsafeEntity<E> = UnsafeZentity<inferZentityType<E>, any>

export type inferEntity<E> = E extends EntityClass<infer S, infer R> ? Zentity<ZodShapeType<S>, R> : never


export type inferPlainTypeFromZentity<E> = E extends Zentity<infer P, infer R> ? P & EntityCore : never

export type ZodShapeType<S extends ZodRawShape> = z.infer<ZodObject<S>>

export type Extender<S extends ZodRawShape, R extends object = {}> = (e: EntityCore & ZodShapeType<S>) => R

export function entity<S extends ZodRawShape, R extends object = {}>(options: {
    name: string,
    shape: S,
    extend?: Extender<S, R>,
}): EntityClass<S, R> {
    const shape = {
        ...EntityCoreShape,
        ...options.shape,
    }

    const schema = z.object(shape)

    const extend = options.extend ?? ((_: EntityCore & ZodShapeType<S>) => ({} as R))

    type P = ZodShapeType<S>


    const create = (params: P & EntityCore): Zentity<P, R> => {
        const data = schema.parse(params) as any

        return {
            _brand: UnsafeEntitySymbol,
            _safe: EntitySymbol,
            ...data,
            copy: copyFn(data),
            ...extend(data),
            validate: toSafeFn(data),
            toPlain: () => data
        }
    }


    const toSafeFn = (params: P & EntityCore) => () => {
        return create(params)
    }
    const copyFn = (params: P & EntityCore) => (fields: Partial<P & EntityCore>) => {
        return create({
            ...params,
            ...fields,
        })
    }


    return {
        name: options.name,
        create,
        new: (params: P & { id: string }): Zentity<P, R> => {
            const createdAt = new Date()
            const updatedAt = new Date()
            return create({
                ...params,
                createdAt,
                updatedAt,
            })
        },
        unsafe: (params: P & EntityCore): UnsafeZentity<P, R> => {
            return {
                _brand: UnsafeEntitySymbol,
                ...params,
                copy: copyFn(params),
                ...extend(params),
                validate: toSafeFn(params),
                toPlain: () => {
                    return params
                }
            }
        },
        schema,
        shape,
        extend,
    }
}