import os
import toml
import toml.ast
import x.json2

const hide_oks = os.getenv('VTEST_HIDE_OK') == '1'
const no_jq = os.getenv('VNO_JQ') == '1'

// Instructions for developers:
// The actual tests and data can be obtained by doing:
// `git clone -n https://github.com/toml-rs/toml.git vlib/toml/tests/testdata/toml_rs`
// `git -C vlib/toml/tests/testdata/toml_rs reset --hard 9bd454c`
// See also the CI toml tests
// Kept for easier handling of future updates to the tests
const valid_exceptions = [
    'valid/example-v0.3.0.toml',
    'valid/example-v0.4.0.toml',
    'valid/datetime-truncate.toml', // Not considered valid since RFC 3339 doesn't permit > 6 ms digits ??
]
const invalid_exceptions = []string{}

const valid_value_exceptions = [
    // These have correct values, and should've passed, but the format of arrays is *mixed* in the JSON ??
    'valid/datetime-truncate.toml',
    'valid/example2.toml',
    'valid/example-v0.4.0.toml',
    'valid/example-v0.3.0.toml',
]

// These have correct values, and should've passed as-is, but the format of arrays changes in the JSON ??
// We account for that here
const use_type_2_arrays = [
    'valid/table-array-implicit.toml',
    'valid/table-array-many.toml',
    'valid/table-array-one.toml',
    'valid/table-array-nest.toml',
    'valid/table-array-nest-no-keys.toml',
]
const tests_folder = os.join_path('crates', 'test-suite', 'tests')
const jq = os.find_abs_path_of_executable('jq') or { '' }
const compare_work_dir_root = os.join_path(os.vtmp_dir(), 'toml_toml_rs')
// From: https://stackoverflow.com/a/38266731/1904615
const jq_normalize = r'# Apply f to composite entities recursively using keys[], and to atoms
def sorted_walk(f):
  . as $in
  | if type == "object" then
      reduce keys[] as $key
        ( {}; . + { ($key):  ($in[$key] | sorted_walk(f)) } ) | f
  elif type == "array" then map( sorted_walk(f) ) | f
  else f
  end;

def normalize: sorted_walk(if type == "array" then sort else . end);

normalize'

fn run(args []string) !string {
    res := os.execute(args.join(' '))
    if res.exit_code != 0 {
        return error('${args[0]} failed with return code ${res.exit_code}.\n${res.output}')
    }
    return res.output
}

// test_toml_rs_toml_rs run though 'testdata/toml_rs/crates/test-suite/tests/*' if found.
fn test_toml_rs_toml_rs() {
    eprintln('> running ${@LOCATION}')
    test_root := '${@VEXEROOT}/vlib/toml/tests/testdata/toml_rs/crates/test-suite/tests'
    if os.is_dir(test_root) {
        valid_test_files := os.walk_ext(os.join_path(test_root, 'valid'), '.toml')
        invalid_test_files := os.walk_ext(os.join_path(test_root, 'invalid'), '.toml')
        println('Testing ${valid_test_files.len} valid TOML files...')
        mut valid := 0
        mut e := 0
        for i, valid_test_file in valid_test_files {
            mut relative := valid_test_file.all_after(tests_folder).trim_left(os.path_separator)
            $if windows {
                relative = relative.replace('/', '\\')
            }

            if relative in valid_exceptions {
                e++
                idx := valid_exceptions.index(relative) + 1
                println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" VALID EXCEPTION [${idx}/${valid_exceptions.len}]...')
                continue
            }
            if !hide_oks {
                println('OK   [${i + 1}/${valid_test_files.len}] "${valid_test_file}"...')
            }
            toml_doc := toml.parse_file(valid_test_file)!
            valid++
        }
        println('${valid}/${valid_test_files.len} TOML files were parsed correctly')
        if valid_exceptions.len > 0 {
            println('TODO Skipped parsing of ${e} valid TOML files...')
        }

        // If the command-line tool `jq` is installed, value tests can be run as well.
        if jq != '' && !no_jq {
            println('Testing value output of ${valid_test_files.len} valid TOML files using "${jq}"...')

            if os.exists(compare_work_dir_root) {
                os.rmdir_all(compare_work_dir_root)!
            }
            os.mkdir_all(compare_work_dir_root)!

            jq_normalize_path := os.join_path(compare_work_dir_root, 'normalize.jq')
            os.write_file(jq_normalize_path, jq_normalize)!

            valid = 0
            e = 0
            for i, valid_test_file in valid_test_files {
                mut relative := valid_test_file.all_after(tests_folder).trim_left(os.path_separator)
                $if windows {
                    relative = relative.replace('/', '\\')
                }
                if !os.exists(valid_test_file.all_before_last('.') + '.json') {
                    println('N/A  [${i + 1}/${valid_test_files.len}] "${valid_test_file}"...')
                    continue
                }
                // Skip the file if we know it can't be parsed or we know that the value retrieval needs work.
                if relative in valid_exceptions {
                    e++
                    idx := valid_exceptions.index(relative) + 1
                    println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" VALID EXCEPTION [${idx}/${valid_exceptions.len}]...')
                    continue
                }
                if relative in valid_value_exceptions {
                    e++
                    idx := valid_value_exceptions.index(relative) + 1
                    println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" VALID VALUE EXCEPTION [${idx}/${valid_value_exceptions.len}]...')
                    continue
                }

                if !hide_oks {
                    println('OK   [${i + 1}/${valid_test_files.len}] "${valid_test_file}"...')
                }
                toml_doc := toml.parse_file(valid_test_file)!

                v_toml_json_path := os.join_path(compare_work_dir_root,

                    os.file_name(valid_test_file).all_before_last('.') + '.v.json')
                toml_rs_toml_json_path := os.join_path(compare_work_dir_root,

                    os.file_name(valid_test_file).all_before_last('.') + '.json')

                mut array_type := 1
                if relative in use_type_2_arrays {
                    array_type = 2
                }

                os.write_file(v_toml_json_path, to_toml_rs(toml_doc.ast.table, array_type))!

                toml_rs_json := os.read_file(valid_test_file.all_before_last('.') + '.json')!

                os.write_file(toml_rs_toml_json_path, toml_rs_json)!

                v_normalized_json := run([jq, '-S', '-f "${jq_normalize_path}"', v_toml_json_path]) or {
                    contents := os.read_file(v_toml_json_path)!
                    panic(err.msg() + '\n${contents}')
                }
                toml_rs_normalized_json := run([jq, '-S', '-f "${jq_normalize_path}"',
                    toml_rs_toml_json_path]) or {
                    contents := os.read_file(v_toml_json_path)!
                    panic(err.msg() + '\n${contents}')
                }

                assert toml_rs_normalized_json == v_normalized_json

                valid++
            }
            println('${valid}/${valid_test_files.len} TOML files were parsed correctly and value checked')
            if valid_value_exceptions.len > 0 {
                println('TODO Skipped value checks of ${e} valid TOML files...')
            }
        }

        println('Testing ${invalid_test_files.len} invalid TOML files...')
        mut invalid := 0
        e = 0
        for i, invalid_test_file in invalid_test_files {
            mut relative := invalid_test_file.all_after(tests_folder).trim_left(os.path_separator)
            $if windows {
                relative = relative.replace('/', '\\')
            }
            if relative in invalid_exceptions {
                e++
                idx := invalid_exceptions.index(relative) + 1
                println('SKIP [${i + 1}/${invalid_test_files.len}] "${invalid_test_file}" INVALID EXCEPTION [${idx}/${invalid_exceptions.len}]...')
                continue
            }

            if !hide_oks {
                println('OK   [${i + 1}/${invalid_test_files.len}] "${invalid_test_file}"...')
            }
            if toml_doc := toml.parse_file(invalid_test_file) {
                content_that_should_have_failed := os.read_file(invalid_test_file)!
                println('     This TOML should have failed:\n${'-'.repeat(40)}\n${content_that_should_have_failed}\n${'-'.repeat(40)}')
                assert false
            } else {
                if !hide_oks {
                    println('     ${err.msg()}')
                }
                assert true
            }
            invalid++
        }
        println('${invalid}/${invalid_test_files.len} TOML files were parsed correctly')
        if invalid_exceptions.len > 0 {
            println('TODO Skipped parsing of ${invalid_exceptions.len} invalid TOML files...')
        }
    } else {
        println('No test data directory found in "${test_root}"')
        assert true
    }
}

// to_toml_rs_time
fn to_toml_rs_time(time_str string) string {
    if time_str.contains('.') {
        date_and_time := time_str.all_before('.')
        mut ms := time_str.all_after('.')
        z := if ms.contains('Z') { 'Z' } else { '' }
        ms = ms.replace('Z', '')
        if ms.len > 3 {
            ms = ms[..3]
        }
        return date_and_time + '.' + ms + z
    } else {
        return time_str
    }
}

// to_toml_rs returns an toml_rs compatible json string converted from the `value` ast.Value.
fn to_toml_rs(value ast.Value, array_type int) string {
    match value {
        ast.Quoted {
            json_text := json2.Any(value.text).json_str()
            return '{ "type": "string", "value": ${json_text} }'
        }
        ast.DateTime {
            // Normalization for json
            mut json_text := json2.Any(value.text).json_str().to_upper().replace(' ', 'T')
            typ := if json_text.ends_with('Z"') || json_text.all_after('T').contains('-')
                || json_text.all_after('T').contains('+') {
                'datetime'
            } else {
                'datetime-local'
            }
            // NOTE test suite inconsistency.
            // It seems it's implementation specific how time and
            // date-time values are represented in detail. For now we follow the toml-lang format
            // that expands to 6 digits which is also a valid RFC 3339 representation.
            json_text = to_toml_rs_time(json_text[1..json_text.len - 1])
            return '{ "type": "${typ}", "value": "${json_text}" }'
        }
        ast.Date {
            json_text := json2.Any(value.text).json_str()
            return '{ "type": "date", "value": ${json_text} }'
        }
        ast.Time {
            mut json_text := json2.Any(value.text).json_str()
            json_text = to_toml_rs_time(json_text[1..json_text.len - 1])
            return '{ "type": "time", "value": "${json_text}" }'
        }
        ast.Bool {
            json_text := json2.Any(value.text.bool()).json_str()
            return '{ "type": "bool", "value": "${json_text}" }'
        }
        ast.Null {
            json_text := json2.Any(value.text).json_str()
            return '{ "type": "null", "value": ${json_text} }'
        }
        ast.Number {
            text := value.text
            if text.contains('inf') || text.contains('nan') {
                return '{ "type": "float", "value": ${value.text} }'
            }
            if !text.starts_with('0x') && (text.contains('.') || text.to_lower().contains('e')) {
                mut val := ''
                if text.to_lower().contains('e') && !text.contains('-') {
                    val = '${value.f64():.1f}'
                } else {
                    val = '${value.f64()}'
                }
                return '{ "type": "float", "value": "${val}" }'
            }
            return '{ "type": "integer", "value": "${value.i64()}" }'
        }
        map[string]ast.Value {
            mut str := '{ '
            for key, val in value {
                json_key := json2.Any(key).json_str()
                str += ' ${json_key}: ${to_toml_rs(val, array_type)},'
            }
            str = str.trim_right(',')
            str += ' }'
            return str
        }
        []ast.Value {
            mut str := ''
            if array_type == 1 {
                str = '{ "type": "array", "value": [ '
            } else {
                str = '[ '
            }
            for val in value {
                str += ' ${to_toml_rs(val, array_type)},'
            }
            str = str.trim_right(',')
            if array_type == 1 {
                str += ' ] }\n'
            } else {
                str += ' ]\n'
            }
            return str
        }
    }

    return '<error>'
}