import { injectable, inject } from 'inversify';
import {
    IClientConfigurationService, ILifecycleService, IConfigurationData,
    IConfigurationOverrides, ConfigurationTarget, IConfigurationModel,
    IConfigurationChangeEvent, IWorkspaceFolder,
} from '../../interfaces';
import { IDisposable, Disposable } from '@vscode-alt/monaco-editor/esm/vs/base/common/lifecycle';
import { WorkspaceConfiguration as Configuration, ConfigurationModel, isConfigurationOverrides } from '../../core';
import { ResourceMap } from '@vscode-alt/monaco-editor/esm/vs/base/common/map';
import { URI } from '@vscode-alt/monaco-editor/esm/vs/base/common/uri';
import { Event, Emitter } from '@vscode-alt/monaco-editor/esm/vs/base/common/event';
import { CdmLogger } from '@cdm-logger/core';


type ILogger = CdmLogger.ILogger;

@injectable()
export abstract class AbstractWorkspaceConfigurationClientService extends Disposable implements IClientConfigurationService, IDisposable {

    private _configuration: Configuration;

    protected logger: ILogger;

    constructor(
        @inject('Logger')
        logger: ILogger,
    ) {
        super();
        this.logger = logger.child({ className: 'WorkspaceConfigurationClientService' });
    }

    private readonly _onDidChangeConfiguration: Emitter<IConfigurationChangeEvent> = this._register(new Emitter<IConfigurationChangeEvent>());
    public readonly onDidChangeConfiguration: Event<IConfigurationChangeEvent> = this._onDidChangeConfiguration.event;

    public abstract extInitialize();

    get configuration() {
        return this._configuration;
    }
    set configuration(configuration: Configuration) {
        this._configuration = configuration;
    }

    public getConfigurationData(): IConfigurationData {
        return this.configuration.toData();
    }


    public getValue<T>(): T;
    public getValue<T>(section: string): T;
    public getValue<T>(overrides: IConfigurationOverrides): T;
    public getValue<T>(section: string, overrides: IConfigurationOverrides): T;
    public getValue(arg1?: any, arg2?: any): any {
        const section = typeof arg1 === 'string' ? arg1 : undefined;
        const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : {};
        return this.configuration.getValue(section, overrides);
    }

    public abstract updateValue(key: string, value: any): Promise<void>;
    public abstract updateValue(key: string, value: any, overrides: IConfigurationOverrides): Promise<void>;
    public abstract updateValue(key: string, value: any, target: ConfigurationTarget): Promise<void>;
    public abstract updateValue(key: string, value: any, overrides: IConfigurationOverrides, target: ConfigurationTarget): Promise<void>;
    public abstract updateValue(key: string, value: any, overrides: IConfigurationOverrides, target: ConfigurationTarget, donotNotifyError: boolean): Promise<void>;
    public abstract updateValue(key: string, value: any, arg3?: any, arg4?: any, donotNotifyError?: any): Promise<void> 
    
    public abstract reloadConfiguration(folder?: IWorkspaceFolder): Promise<void>;

    public inspect<T>(key: string, overrides?: IConfigurationOverrides): {
        default: T,
        user: T,
        userLocal?: T,
        userRemote?: T,
        workspace?: T,
        workspaceFolder?: T,
        memory?: T,
        value: T
    } {
        return this.configuration.inspect<T>(key, overrides);
    }
    public keys(): {
        default: string[];
        user: string[];
        workspace: string[];
        workspaceFolder: string[];
    } {
        return this.configuration.keys();
    }

    public extAcceptConfigurationChanged(data: IConfigurationData, event: IConfigurationChangeEvent) {
        this._configuration = AbstractWorkspaceConfigurationClientService.parse(data);
        // this._confugrationScopes = data.configurationScopes;
        this._onDidChangeConfiguration.fire(event);
    }

    public static parse(data: IConfigurationData): Configuration {
        const defaultConfiguration = AbstractWorkspaceConfigurationClientService.parseConfigurationModel(data.defaults);
        const userConfiguration = AbstractWorkspaceConfigurationClientService.parseConfigurationModel(data.user);
        const workspaceConfiguration = AbstractWorkspaceConfigurationClientService.parseConfigurationModel(data.workspace);
        const folders: ResourceMap<ConfigurationModel> = Object.keys(data.folders).reduce((result, key) => {
            result.set(URI.parse(key), AbstractWorkspaceConfigurationClientService.parseConfigurationModel(data.folders[key]));
            return result;
        }, new ResourceMap<ConfigurationModel>());
        return new Configuration(defaultConfiguration, userConfiguration,
            new ConfigurationModel(), workspaceConfiguration, folders, new ConfigurationModel(), new ResourceMap<ConfigurationModel>());
    }

    protected static parseConfigurationModel(model: IConfigurationModel): ConfigurationModel {
        return new ConfigurationModel(model.contents, model.keys, model.overrides).freeze();
    }

}