import type { LocationUri, MimeTypeAction, StorageAction } from './squared';

import type { IDocument, IFileManager, IModule } from './index';
import type { ExternalAsset, InitialValue } from './asset';
import type { CloudStorage } from './cloud';
import type { LogComponent, LogDate } from './logger';
import type { DocumentTransform } from './settings';

export interface DocumentAsset extends ExternalAsset, StorageAction<CloudStorage> {
    initialValue?: InitialValue & { inlineFilename?: string };
}

export interface StartOfSourceMap {
    file?: string;
    sourceRoot?: string;
}

export interface RawSourceMap<T = NumString> extends StartOfSourceMap {
    version: T;
    sources: string[];
    names: string[];
    sourcesContent?: string[];
    mappings: string;
}

export interface SourceInput<T = [string, string?, string?][]> {
    code?: string;
    sourceFile?: T;
    sourceName?: string;
    sourcesRelativeTo?: string;
}

export interface SourceCode {
    code: string;
    map?: RawSourceMap;
    sourceMappingURL?: string;
}

export interface ChunkFile {
    code: string;
    filename?: string;
    entryPoint?: boolean;
}

export interface ChunkData extends ChunkFile {
    sourceMap?: SourceMap;
}

export interface CacheData {
    uri?: string;
    etag?: string;
    encoding?: BufferEncoding;
    override?: boolean;
}

export interface TransformAction {
    cacheData?: CacheData;
}

export interface TransformResult extends SourceCode {
    type?: string;
    chunks?: Null<(SourceCode & ChunkFile)[]>;
    sourceFiles?: string[];
}

export interface TransformOutput extends Partial<LocationUri>, Omit<SourceInput<string>, "code">, MimeTypeAction {
    imported?: boolean;
    sourceMap?: SourceMap;
    metadata?: unknown;
    external?: PlainObject;
    productionRelease?: boolean;
    getMainFile?(code?: string, imports?: StringMap): Undef<SourceInput<string>>;
    getSourceFiles?(imports?: StringMap): Undef<SourceInput>;
}

export interface TransformOptions<T = AnyObject, U = T> extends TransformOutput {
    baseConfig: T;
    outputConfig: U;
    sourceMap: SourceMap;
    supplementChunks: ChunkData[];
}

export interface ITransformSeries<T = AnyObject, U = T> extends IModule, TransformOptions<T, U> {
    readonly type: string;
    init(instance: IModule, dirname?: string): this;
    close(instance: IModule): void;
    createSourceMap(value: string): SourceMap;
    getMainFile(code?: string, imports?: StringMap): Undef<SourceInput<string>>;
    getSourceFiles(imports?: StringMap): Undef<SourceInput>;
    toBaseConfig(all?: boolean): T;
    upgrade<V = unknown>(context: V, dirname?: string, name?: string): V;
    set code(value);
    get code(): string;
    get out(): IOut;
    get metadata(): object;
    get options(): TransformOutput;
    get productionRelease(): boolean;
    get imported(): boolean;
    set version(value);
    get version(): string;
    set packageName(value);
    get packageName(): string;
    get packageVersion(): string;
    get username(): string;
}

export interface TransformSeriesConstructor {
    readonly prototype: ITransformSeries;
    new(type: string, code: string, options: TransformOutput): ITransformSeries;
}

export interface IOut extends OutV3, OutV4 {}

export interface OutV3 {
    sourceFiles?: string[];
    ignoreCache?: boolean;
    logAppend?: LogComponent[];
    messageAppend?: string;
}

export interface OutV4 {
    logQueued?: LogComponent[];
}

export interface SourceMapOptions extends MimeTypeAction {
    file?: string;
    hash?: string;
    sourceRoot?: string;
    sourceMappingURL?: string;
    inlineMap?: boolean;
    emptySources?: boolean;
}

export interface SourceMap extends SourceCode {
    output: Map<string, SourceCode>;
    reset(): void;
    nextMap(name: string, code: string, map: unknown, sourceMappingURL?: string, emptySources?: boolean): boolean;
    set map(value);
    get map(): Undef<RawSourceMap>;
}

export interface SourceMapConstructor {
    findSourceMap(code?: string, uri?: string): Undef<RawSourceMap>;
    removeSourceMappingURL(value: string): [string, string?, Null<RawSourceMap>?];
    isRaw(map: unknown): map is RawSourceMap;
    readonly prototype: SourceMap;
    new(code: string, remove: boolean): SourceMap;
    new(code: string, uri?: string, remove?: boolean): SourceMap;
}

export interface ImportMap {
    imports?: StringMap;
    scopes?: ObjectMap<StringMap>;
}

export interface UpdateGradleOptions {
    multiple?: boolean;
    addendum?: string;
    upgrade?: boolean;
    updateOnly?: boolean;
}

export interface LintMessage {
    ruleId: string;
    message: string;
    line: number;
    column: number;
    endLine?: number;
    endColumn?: number;
    severity?: 0 | 1 | 2 | "" | "error" | "warning";
    fatal?: boolean;
}

export interface GenerateLintTableOptions extends Partial<LocationUri> {
    leadingText?: string;
    trailingText?: string;
    errorCount?: number;
    warningCount?: number;
    fatalErrorCount?: number;
    timeStamp?: LogDate;
    ruleWidth?: number;
    messageWidth?: number;
}

export interface CustomizeOptions {
    transform?: DocumentTransform;
}

export interface AsSourceFileOptions {
    encoding?: BufferEncoding;
    persist?: boolean;
    cache?: boolean;
}

export type Transformer = FunctionType<Undef<Promise<string> | string>>;
export type ConfigOrTransformer = AnyObject | Transformer;
export type PluginConfig = [string, Undef<ConfigOrTransformer>, Undef<AnyObject>, boolean?] | [];
export type TransformCallback<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> = (this: T, instance: IDocument<T, U>, requireOrDocumentDir?: NodeJS.Require | string) => Void<Promise<void>>;