import * as fs from 'fs'
import * as path from 'path'
import * as vscode from 'vscode'



export interface TextMateRule {
    scope: string | string[]
    settings: TextMateRuleSettings
}

export interface TextMateRuleSettings {
    foreground: string | undefined
    background: string | undefined
    fontStyle: string | undefined
}

// Current theme colors
const rules = new Map<string, TextMateRuleSettings>()

export function find(scope: string): TextMateRuleSettings | undefined {
    return rules.get(scope)
}

// Load all textmate scopes in the currently active theme
export function load() {
    // Remove any previous theme
    rules.clear()
    // Find out current color theme
    const themeName = vscode.workspace.getConfiguration('workbench').get('colorTheme')

    if (typeof themeName !== 'string') {
        // console.warn('workbench.colorTheme is', themeName)
        return
    }
    // Try to load colors from that theme
    try {
        loadThemeNamed(themeName)
    } catch (e) {
        // console.warn('failed to load theme', themeName, e)
    }
}

function filterThemeExtensions(extension: vscode.Extension<any>): boolean {
    return extension.extensionKind === vscode.ExtensionKind.UI &&
        extension.packageJSON.contributes &&
        extension.packageJSON.contributes.themes
}



// Find current theme on disk
function loadThemeNamed(themeName: string) {

    const themePaths = vscode.extensions.all
        .filter(filterThemeExtensions)
        .reduce((list, extension) => {
            return extension.packageJSON.contributes.themes
                .filter((element: any) => (element.id || element.label) === themeName)
                .map((element: any) => path.join(extension.extensionPath, element.path))
                .concat(list)
        }, Array<string>())


    themePaths.forEach(loadThemeFile)

    const tokenColorCustomizations: [any] = [vscode.workspace.getConfiguration('editor').get('tokenColorCustomizations')]

    tokenColorCustomizations
        .filter(custom => custom && custom.textMateRules)
        .map(custom => custom.textMateRules)
        .forEach(loadColors)

}


function loadThemeFile(themePath: string) {
    const themeContent = [themePath]
        .filter(isFile)
        .map(readFileText)
        .map(parseJSON)
        .filter(theme => theme)

    themeContent
        .filter(theme => theme.tokenColors)
        .map(theme => theme.tokenColors)
        .forEach(loadColors)

    themeContent
        .filter(theme => theme.include)
        .map(theme => path.join(path.dirname(themePath), theme.include))
        .forEach(loadThemeFile)
}

function mergeRuleSettings(defaultSetting: TextMateRuleSettings | undefined, override: TextMateRuleSettings): TextMateRuleSettings {
    if (defaultSetting === undefined) { return override }
    const mergedRule = defaultSetting

    mergedRule.background = override.background || defaultSetting.background
    mergedRule.foreground = override.foreground || defaultSetting.foreground
    mergedRule.fontStyle = override.fontStyle || defaultSetting.foreground

    return mergedRule
}

function updateRules(scope: string, updatedSettings: TextMateRuleSettings): void {
    [rules.get(scope)]
        .map(settings => mergeRuleSettings(settings, updatedSettings))
        .forEach(settings => rules.set(scope, settings))
}

function loadColors(textMateRules: TextMateRule[]): void {
    textMateRules.forEach(rule => {
        if (typeof rule.scope === 'string') {
            updateRules(rule.scope, rule.settings)
        }
        else if (rule.scope instanceof Array) {
            rule.scope.forEach(scope => updateRules(scope, rule.settings))
        }
    })
}

function isFile(filePath: string): boolean {
    return [filePath].map(fs.statSync).every(stat => stat.isFile())
}

function readFileText(filePath: string): string {
    return fs.readFileSync(filePath, 'utf8')
}

// Might need to replace with JSONC if a theme contains comments. 
function parseJSON(content: string): any {
    return JSON.parse(content)
}