// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT License.

import { ChildProcess, SpawnOptions as ChildProcessSpawnOptions } from 'child_process';

import { Observable } from 'rxjs/Observable';

import { CancellationToken, Uri } from 'vscode';

import { Architecture } from '../platform/types';

import { ExecutionInfo } from '../types';

import { EnvironmentVariables } from '../variables/types';

export const IBufferDecoder = Symbol('IBufferDecoder');

export interface IBufferDecoder {

decode(buffers: Buffer[], encoding: string): string;

}

export type Output<T extends string | Buffer> = {

source: 'stdout' | 'stderr';

out: T;

};

export type ObservableExecutionResult<T extends string | Buffer> = {

proc: ChildProcess;

out: Observable<Output<T>>;

};

// tslint:disable-next-line:interface-name

export type SpawnOptions = ChildProcessSpawnOptions & {

encoding?: string;

token?: CancellationToken;

mergeStdOutErr?: boolean;

throwOnStdErr?: boolean;

};

export type ExecutionResult<T extends string | Buffer> = {

stdout: T;

stderr?: T;

};

export interface IProcessService {

execObservable(file: string, args: string[], options?: SpawnOptions): ObservableExecutionResult<string>;

exec(file: string, args: string[], options?: SpawnOptions): Promise<ExecutionResult<string>>;

}

export const IProcessServiceFactory = Symbol('IProcessServiceFactory');

export interface IProcessServiceFactory {

create(resource?: Uri): Promise<IProcessService>;

}

export const IPythonExecutionFactory = Symbol('IPythonExecutionFactory');

export type ExecutionFactoryCreationOptions = {

resource?: Uri;

pythonPath?: string;

};

export interface IPythonExecutionFactory {

create(options: ExecutionFactoryCreationOptions): Promise<IPythonExecutionService>;

}

export type ReleaseLevel = 'alpha' | 'beta' | 'candidate' | 'final';

// tslint:disable-next-line:interface-name

export type PythonVersionInfo = [number, number, number, ReleaseLevel];

export type InterpreterInfomation = {

path: string;

version: string;

sysVersion: string;

architecture: Architecture;

version_info: PythonVersionInfo;

sysPrefix: string;

};

export const IPythonExecutionService = Symbol('IPythonExecutionService');

export interface IPythonExecutionService {

getInterpreterInformation(): Promise<InterpreterInfomation | undefined>;

getExecutablePath(): Promise<string>;

isModuleInstalled(moduleName: string): Promise<boolean>;

execObservable(args: string[], options: SpawnOptions): ObservableExecutionResult<string>;

execModuleObservable(moduleName: string, args: string[], options: SpawnOptions): ObservableExecutionResult<string>;

exec(args: string[], options: SpawnOptions): Promise<ExecutionResult<string>>;

execModule(moduleName: string, args: string[], options: SpawnOptions): Promise<ExecutionResult<string>>;

}

export class StdErrError extends Error {

constructor(message: string) {

super(message);

}

}

export interface IExecutionEnvironmentVariablesService {

getEnvironmentVariables(resource?: Uri): Promise<EnvironmentVariables | undefined>;

}

export const IPythonToolExecutionService = Symbol('IPythonToolRunnerService');

export interface IPythonToolExecutionService {

execObservable(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ObservableExecutionResult<string>>;

exec(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ExecutionResult<string>>;

}