import { existsSync, lstatSync, readFileSync } from 'fs'
import { AllPaths } from './main'
import {
    UserScriptMeta,
    UserScriptMetaFull,
    UserScriptMetaPartial,
} from './types'

export default interface readMeta {
    meta: UserScriptMetaFull
    metaString: string
}

export default function readMeta(name: string) {
    let paths = AllPaths.script(name)
    let urls = AllPaths.url

    var meta: UserScriptMetaFull = {
        name: name,
        namespace: 'zomo.dev',
        match: '',
        excludematch: '',
        version: '0.0.0',
        description: '',
        icon: '',
        require: '',
        resource: '',
        runat: '',
        noframes: false,
        grant: '',
        injectinto: '',
        downloadURL: paths.url,
        supportURL: urls.support,
        homepageURL: urls.home,
        unwrap: false,
    }

    let metaPath = paths.meta

    if (existsSync(metaPath) && lstatSync(metaPath).isFile()) {
        try {
            let args: UserScriptMetaPartial = JSON.parse(
                readFileSync(metaPath).toString()
            )

            let key: keyof UserScriptMeta
            for (key in meta) {
                let val = args[key]

                //cases where the value is empty
                if (val === undefined) continue
                if (val === false) continue
                if (val === '')
                    continue

                    //:)
                ;(meta[key] as any) = val
            }
        } catch (e) {
            console.log(e)
        }
    } else {
        console.log(`${metaPath} not found, using default metadata`)
    }

    const keyConversion = {
        injectinto: 'inject-into',
        excludematch: 'exclude-match',
    }

    return {
        meta,
        metaString: `// ==UserScript==
${(Object.keys(meta) as Array<keyof UserScriptMetaFull>)
    .filter(key => {
        let val = meta[key]
        if (val === undefined) return false
        if (val === false) return false
        if (val === '') return false
        return true
    })
    .map(key => {
        let val = meta[key]
        let key_str: string =
            key in keyConversion
                ? keyConversion[key as keyof typeof keyConversion]
                : key
        key_str = key_str.padEnd(12, ' ')

        if (typeof val === 'boolean') {
            //bool
            if (val) return `// @${key_str}`
        } else if (typeof val === 'string') {
            //string
            return `// @${key_str} ${val}`
        } else if (Array.isArray(val)) {
            //multiple
            return val.map(v => `// @${key_str} ${v}`).join('\n')
        } else if (typeof val === 'object') {
            //multilingual
            let langs = val
            return Object.keys(langs)
                .map(lang => {
                    let langStr = lang === 'default' ? '' : `:${lang}`
                    return `// @${key_str}${langStr} ${langs[lang]}`
                })
                .join('\n')
        }

        return ''
    })
    .filter(l => l.length)
    .join('\n')}
// ==/UserScript==
`,
    }
}