/* eslint-disable class-methods-use-this */
/* eslint-disable no-nested-ternary */
import { injectable, inject } from 'inversify';
import { IDisposable, Disposable } from '@vscode-alt/monaco-editor/esm/vs/base/common/lifecycle';
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';
import { Configuration, ConfigurationModel, isConfigurationOverrides } from '../../core';
import {
    IClientConfigurationService,
    ILifecycleService,
    IConfigurationData,
    IConfigurationOverrides,
    ConfigurationTarget,
    IConfigurationModel,
    IConfigurationChangeEvent,
    IWorkspaceFolder,
} from '../../interfaces';

type ILogger = CdmLogger.ILogger;

@injectable()
export abstract class AbstractConfigurationClientService
    extends Disposable
    implements IClientConfigurationService, IDisposable
{
    private _configuration: Configuration;

    protected logger: ILogger;

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

    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, undefined);
    }

    public updateValue(key: string, value: any): Promise<void>;

    public updateValue(key: string, value: any, overrides: IConfigurationOverrides): Promise<void>;

    public updateValue(key: string, value: any, target: ConfigurationTarget): Promise<void>;

    public updateValue(
        key: string,
        value: any,
        overrides: IConfigurationOverrides,
        target: ConfigurationTarget,
    ): Promise<void>;

    public updateValue(key: string, value: any, arg3?: any, arg4?: any): Promise<void> {
        return Promise.reject(new Error('not supported'));
    }

    public inspect<T>(key: string): {
        default: T;
        user: T;
        workspace?: T;
        workspaceFolder?: T;
        value: T;
    } {
        return this.configuration.inspect<T>(key, {}, undefined);
    }

    public keys(): {
        default: string[];
        user: string[];
        workspace: string[];
        workspaceFolder: string[];
    } {
        return this.configuration.keys(undefined);
    }

    public abstract reloadConfiguration(folder?: IWorkspaceFolder): Promise<void>;

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

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

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