import { injectable } from 'inversify';
import { IRegistry, RegistryHive } from '../../client/common/platform/types';
import { IPersistentState } from '../../client/common/types';
import { Architecture } from '../../client/common/utils/platform';
import { IInterpreterVersionService } from '../../client/interpreter/contracts';

@injectable()
export class MockRegistry implements IRegistry {
    constructor(
        private keys: { key: string; hive: RegistryHive; arch?: Architecture; values: string[] }[],
        private values: { key: string; hive: RegistryHive; arch?: Architecture; value: string; name?: string }[]
    ) {}
    public async getKeys(key: string, hive: RegistryHive, arch?: Architecture): Promise<string[]> {
        const items = this.keys.find(item => {
            if (typeof item.arch === 'number') {
                return item.key === key && item.hive === hive && item.arch === arch;
            }
            return item.key === key && item.hive === hive;
        });

        return items ? Promise.resolve(items.values) : Promise.resolve([]);
    }
    public async getValue(
        key: string,
        hive: RegistryHive,
        arch?: Architecture,
        name?: string
    ): Promise<string | undefined | null> {
        const items = this.values.find(item => {
            if (item.key !== key || item.hive !== hive) {
                return false;
            }
            if (typeof item.arch === 'number' && item.arch !== arch) {
                return false;
            }
            if (name && item.name !== name) {
                return false;
            }
            return true;
        });

        return items ? Promise.resolve(items.value) : Promise.resolve(null);
    }
}

// tslint:disable-next-line:max-classes-per-file
@injectable()
export class MockInterpreterVersionProvider implements IInterpreterVersionService {
    constructor(
        private displayName: string,
        private useDefaultDisplayName: boolean = false,
        private pipVersionPromise?: Promise<string>
    ) {}
    public async getVersion(_pythonPath: string, defaultDisplayName: string): Promise<string> {
        return this.useDefaultDisplayName ? Promise.resolve(defaultDisplayName) : Promise.resolve(this.displayName);
    }
    public async getPipVersion(_pythonPath: string): Promise<string> {
        // tslint:disable-next-line:no-non-null-assertion
        return this.pipVersionPromise!;
    }
    // tslint:disable-next-line:no-empty
    public dispose() {}
}

// tslint:disable-next-line:no-any max-classes-per-file
export class MockState implements IPersistentState<any> {
    // tslint:disable-next-line:no-any
    constructor(public data: any) {}
    // tslint:disable-next-line:no-any
    get value(): any {
        return this.data;
    }
    // tslint:disable-next-line:no-any
    public async updateValue(data: any): Promise<void> {
        this.data = data;
    }
}