import { Repository as TypeormRepository } from 'typeorm'
import { Type, Injector, EntityService } from '@notadd/core';
import { Connection, getMetadataArgsStorage, FindOneOptions, FindManyOptions, SaveOptions, DeleteResult, ObjectID, InsertResult, RemoveOptions, EntityManager, UpdateResult, QueryRunner, EntityMetadata, SelectQueryBuilder, DeepPartial, FindConditions } from 'typeorm';
import { MetadataArgsStorage } from 'typeorm/metadata-args/MetadataArgsStorage';
import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
import { define, Table, ColumnDefinition, QueryLike, Query, Executable } from './sql-helper';
import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
export function createColumn<Name extends string, T>(column: ColumnMetadata): ColumnDefinition<Name, T> {
    return {
        name: column.propertyName as Name,
        dataType: column.type as any
    }
}
export function createColumns<Name extends string, T>(columns: ColumnMetadata[]): any {
    const res = {};
    columns.map(column => {
        Reflect.set(res, column.propertyName, createColumn(column))
    })
    return res;
}
export function createTable<Name extends string, T>(metadata: EntityMetadata): Table<Name, T> {
    return define<Name, T>({
        name: metadata.tableName as Name,
        schema: metadata.schema || '',
        columns: createColumns<Name, T>(metadata.columns)
    })
}
export function isExecutable(val: any): val is Executable {
    return val && Reflect.has(val, 'toQuery')
}
export class Repository<Entity> implements TypeormRepository<Entity>{
    manager: EntityManager;
    metadata: EntityMetadata;
    queryRunner?: QueryRunner;
    entityService: EntityService;
    get table() {
        return createTable<string, Entity>(this.metadata)
    }
    constructor(public repository: TypeormRepository<Entity>, public injector: Injector, public entity: Type<Entity>) {
        this.entityService = this.injector.get(EntityService)
        this.metadata = this.repository.metadata;
        this.manager = this.repository.manager;
        this.queryRunner = this.repository.queryRunner;
    }
    createQueryBuilder(alias?: string | undefined, queryRunner?: QueryRunner): SelectQueryBuilder<Entity> {
        return this.manager.createQueryBuilder(this.entity, alias || this.entity.name, queryRunner || this.queryRunner);
    }
    get target() {
        return this.entity;
    }
    sql(sqlLike: QueryLike | Query<Entity>): Promise<any> {
        if (isExecutable(sqlLike)) {
            return this.sql(sqlLike.toQuery())
        } else {
            return this.query(sqlLike.text, sqlLike.values)
        }
    }
    hasId(entity: Entity): boolean {
        return this.repository.hasId(entity)
    }
    getId(entity: Entity) {
        return this.repository.getId(entity)
    }
    create(): Entity;
    create(entityLikeArray: DeepPartial<Entity>[]): Entity[];
    create(entityLike: DeepPartial<Entity>): Entity;
    create(entityLike?: any) {
        if (entityLike) {
            return this.repository.create(entityLike)
        } else {
            return this.repository.create()
        }
    }
    createAsync(): Promise<Entity>;
    createAsync(entityLikeArray: DeepPartial<Entity>[]): Promise<Entity[]>;
    createAsync(entityLike: DeepPartial<Entity>): Promise<Entity>;
    async createAsync(entityLike?: any) {
        if (Array.isArray(entityLike)) {
            return await Promise.all(entityLike.map(it => this.createAsync(it)))
        } else if (entityLike) {
            return this.entityService.create(entityLike, this.target)
        } else {
            return this.entityService.create(entityLike, this.target)
        }
    }
    merge(mergeIntoEntity: Entity, ...entityLikes: DeepPartial<Entity>[]): Entity {
        return this.repository.merge(mergeIntoEntity, ...entityLikes)
    }
    async preload(entityLike: DeepPartial<Entity>): Promise<Entity | undefined> {
        entityLike = await this.entityService.create(entityLike as any, this.entity) as any;
        return this.repository.preload(entityLike)
    }
    save<T extends DeepPartial<Entity>>(entities: T[], options: SaveOptions & { reload: false; }): Promise<T[]>;
    save<T extends DeepPartial<Entity>>(entities: T[], options?: SaveOptions | undefined): Promise<(T & Entity)[]>;
    save<T extends DeepPartial<Entity>>(entity: T, options: SaveOptions & { reload: false; }): Promise<T>;
    save<T extends DeepPartial<Entity>>(entity: T, options?: SaveOptions | undefined): Promise<T & Entity>;
    async save(entity: any, options?: any) {
        const type = entity.constructor
        if (type) {
            if (type.name === 'Object') {
                // entity = await this.createAsync(entity as any)
            }
        }
        return this.repository.save(entity, options)
    }
    remove(entities: Entity[], options?: RemoveOptions | undefined): Promise<Entity[]>;
    remove(entity: Entity, options?: RemoveOptions | undefined): Promise<Entity>;
    remove(entity: any, options?: any): Promise<any> {
        if (Array.isArray(entity)) {
            return this.repository.remove(entity, options)
        } else {
            return this.repository.remove(entity, options)
        }
    }
    softRemove<T extends DeepPartial<Entity>>(entities: T[], options: SaveOptions & { reload: false; }): Promise<T[]>;
    softRemove<T extends DeepPartial<Entity>>(entities: T[], options?: SaveOptions | undefined): Promise<(T & Entity)[]>;
    softRemove<T extends DeepPartial<Entity>>(entity: T, options: SaveOptions & { reload: false; }): Promise<T>;
    softRemove<T extends DeepPartial<Entity>>(entity: T, options?: SaveOptions | undefined): Promise<T & Entity>;
    softRemove(entity: any, options?: any) {
        return this.repository.softRemove(entity, options)
    }

    recover<T extends DeepPartial<Entity>>(entities: T[], options: SaveOptions & { reload: false; }): Promise<T[]>;
    recover<T extends DeepPartial<Entity>>(entities: T[], options?: SaveOptions | undefined): Promise<(T & Entity)[]>;
    recover<T extends DeepPartial<Entity>>(entity: T, options: SaveOptions & { reload: false; }): Promise<T>;
    recover<T extends DeepPartial<Entity>>(entity: T, options?: SaveOptions | undefined): Promise<T & Entity>;
    recover(entity: any, options?: any) {
        return this.repository.recover(entity, options)
    }
    async insert(entity: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[]): Promise<InsertResult> {
        const type = entity.constructor
        if (type) {
            if (type.name === 'Object') {
                // entity = await this.createAsync(entity as any)
            }
        }
        return this.repository.insert(entity)
    }
    update(criteria: string | number | string[] | number[] | Date | Date[] | ObjectID | ObjectID[] | FindConditions<Entity>, partialEntity: QueryDeepPartialEntity<Entity>): Promise<UpdateResult> {
        return this.repository.update(criteria, partialEntity)
    }
    delete(criteria: string | number | string[] | number[] | Date | Date[] | ObjectID | ObjectID[] | FindConditions<Entity>): Promise<DeleteResult> {
        return this.repository.delete(criteria)
    }
    softDelete(criteria: string | number | string[] | number[] | Date | Date[] | ObjectID | ObjectID[] | FindConditions<Entity>): Promise<UpdateResult> {
        return this.repository.softDelete(criteria)
    }
    restore(criteria: string | number | string[] | number[] | Date | Date[] | ObjectID | ObjectID[] | FindConditions<Entity>): Promise<UpdateResult> {
        return this.repository.restore(criteria)
    }
    count(options?: FindManyOptions<Entity> | undefined): Promise<number>;
    count(conditions?: FindConditions<Entity> | undefined): Promise<number>;
    count(conditions?: any) {
        return this.repository.count(conditions)
    }
    find(options?: FindManyOptions<Entity> | undefined): Promise<Entity[]>;
    find(conditions?: FindConditions<Entity> | undefined): Promise<Entity[]>;
    find(conditions?: any): any {
        return this.repository.find(conditions)
    }
    findAndCount(options?: FindManyOptions<Entity> | undefined): Promise<[Entity[], number]>;
    findAndCount(conditions?: FindConditions<Entity> | undefined): Promise<[Entity[], number]>;
    findAndCount(conditions?: any) {
        return this.repository.findAndCount(conditions)
    }
    findByIds(ids: any[], options?: FindManyOptions<Entity> | undefined): Promise<Entity[]>;
    findByIds(ids: any[], conditions?: FindConditions<Entity> | undefined): Promise<Entity[]>;
    findByIds(ids: any, conditions?: any) {
        return this.repository.findByIds(conditions)
    }
    findOne(id?: string | number | Date | ObjectID | undefined, options?: FindOneOptions<Entity> | undefined): Promise<Entity | undefined>;
    findOne(options?: FindOneOptions<Entity> | undefined): Promise<Entity | undefined>;
    findOne(conditions?: FindConditions<Entity> | undefined, options?: FindOneOptions<Entity> | undefined): Promise<Entity | undefined>;
    findOne(id?: any,conditions?: any, options?: any) {
        return this.repository.findOne(id,conditions)
    }
    findOneOrFail(id?: string | number | Date | ObjectID | undefined, options?: FindOneOptions<Entity> | undefined): Promise<Entity>;
    findOneOrFail(options?: FindOneOptions<Entity> | undefined): Promise<Entity>;
    findOneOrFail(conditions?: FindConditions<Entity> | undefined, options?: FindOneOptions<Entity> | undefined): Promise<Entity>;
    findOneOrFail(id?: any,conditions?: any, options?: any) {
        return this.repository.findOneOrFail(id,conditions)
    }
    query(query: string, parameters?: any[] | undefined): Promise<any> {
        return this.repository.query(query, parameters)
    }
    clear(): Promise<void> {
        return this.repository.clear()
    }
    increment(conditions: FindConditions<Entity>, propertyPath: string, value: string | number): Promise<UpdateResult> {
        return this.repository.increment(conditions, propertyPath, value)
    }
    decrement(conditions: FindConditions<Entity>, propertyPath: string, value: string | number): Promise<UpdateResult> {
        return this.repository.decrement(conditions, propertyPath, value)
    }
}

export function createRepository<T>(entity: Type<T>, injector: Injector) {
    const connection = injector.get<Connection>(Connection)
    const store: MetadataArgsStorage = getMetadataArgsStorage()
    const table = store.tables.find(table => table.target === entity);
    let repository: TypeormRepository<T>;
    if (table) {
        repository = connection.getRepository(entity)
    } else {
        repository = connection.getTreeRepository(entity)
    }
    return new Repository(repository, injector, entity)
}