import { Module, ModuleWithProviders, StaticInjector, InjectionToken, Type, Injector, Middleware } from '@notadd/core';
import { Connection, ConnectionOptions, MetadataArgsStorage, getMetadataArgsStorage } from './typeorm-native';
import { TYPEORM_ENTITIES } from './token';
import { createRootProviders } from './util';
import { CONTROLLER_MIDDLEWARES } from '@notadd/core'
import { createRepository } from './repository';
@Module({
	providers: [],
})
export class TypeormModule {
	static forRoot(
		options: ConnectionOptions | InjectionToken<ConnectionOptions>
	): ModuleWithProviders {
		return {
			ngModule: TypeormModule,
			providers: [...createRootProviders(options)],
		};
	}

	static forFeature(
		entities: Type<any>[]
	): ModuleWithProviders {
		if (entities.some((it) => !it)) {
			const msg = entities
				.filter((it) => !!it)
				.map((it) => it.name)
				.join(',');
			throw new Error(`请检查注入的Entity有没有循环依赖,正常的有${msg}`);
		}
		return {
			ngModule: TypeormModule,
			providers: [
				{
					provide: TYPEORM_ENTITIES,
					useValue: entities,
					multi: true
				},
				{
					provide: CONTROLLER_MIDDLEWARES,
					useFactory: () => {
						return new Middleware('typeorm forfeature', async (root: Injector | Promise<Injector>) => {
							const injector = await root;
							if (injector instanceof StaticInjector) {
								injector.addProviders(entities.map(entity => {
									return {
										provide: entity,
										useFactory: (injector: Injector) => {
											return createRepository(entity, injector)
										},
										deps: [Injector]
									}
								}))
							}
							return injector;
						})
					},
					multi: true
				},
				...entities.map(entity => {
					return {
						provide: entity,
						useFactory: (injector: Injector) => {
							const connection = injector.get<Connection>(Connection)
							const store: MetadataArgsStorage = getMetadataArgsStorage()
							const table = store.tables.find(table => table.target === entity);
							if (table) {
								return connection.getRepository(entity)
							} else {
								return connection.getTreeRepository(entity)
							}
						},
						deps: [Injector]
					}
				})
			],
		};
	}
}

// Repository<Entity>