package locale_config

import std.unittest.testmacro.*
import std.unittest.*
import std.collection.collectArray


@Test
class LanguageRangeTest {
    @TestCase
    func simpleValidLangRanges() {
        @Assert("en-US",LanguageRange("en-US").toString())
        @Assert("en-US",LanguageRange("EN-US").toString())
        @Assert("en",LanguageRange("en").toString())
        @Assert("eng-Latn-840",LanguageRange("eng-Latn-840").toString())
        @Assert("english",LanguageRange("English").toString())
    }

    @TestCase
    func wildcardLangRanges() {
        @Assert("*",LanguageRange("*").toString())
        @Assert("zh-*",LanguageRange("zh-*").toString())
        @Assert("zh-*-CN",LanguageRange("zh-*-CN").toString())
        @Assert("en-*-simple-*",LanguageRange("En-*-Simple-*").toString())
        @Assert("zh-Hans-*",LanguageRange("zh-hans-*").toString())
    }

    @TestCase
    func complexValidLangRanges() {
        @Assert("de-DE-u-email-co-phonebk-x-linux",LanguageRange("de-DE-u-email-co-phonebk-x-linux").toString())
        @Assert("vi-VN-u-fw-mon-hc-h24-ms-metric",LanguageRange("vi-vn-u-fw-mon-hc-h24-ms-metric").toString())
        @Assert("sl-Cyrl-YU-rozaj-solba-1994-b-1234-a-foobar-x-b-1234-a-foobar",LanguageRange("sl-Cyrl-YU-rozaj-solba-1994-b-1234-a-Foobar-x-b-1234-a-Foobar").toString())
    }

    @TestCase
    func invalidLangRangeInvalidChar() {
        @AssertThrows[IllegalFormatException](LanguageRange("not a range").toString())
    }

    @TestCase
    func invalidLangRangeLongElement() {
        @AssertThrows[IllegalFormatException](LanguageRange("de-DE-u-email-co-phonebook-x-linux").toString())
    }

    @TestCase
    func invalidLangRangeLeadingNumber() {
        @AssertThrows[IllegalFormatException](LanguageRange("840").toString())
    }

    @TestCase
    func invalidLangRangeBadAsterisk() {
        @AssertThrows[IllegalFormatException](LanguageRange("e*-US").toString())
        @AssertThrows[IllegalFormatException](LanguageRange("en-*s").toString())
    }

    @TestCase
    func unixTags() {
        @Assert("cs-CZ",LanguageRange.fromUnix("cs_CZ.UTF-8").toString())
        @Assert("sr-RS-ijekavsk",LanguageRange.fromUnix("sr_RS@ijekavian").toString())
        @Assert("en-Arab",LanguageRange.fromUnix("en@arabic").toString())
        @Assert("en-Arab",LanguageRange.fromUnix("en.UTF-8@arabic").toString())
        @Assert("de-DE",LanguageRange.fromUnix("DE_de.UTF-8@euro").toString())
        @AssertThrows(LanguageRange.fromUnix("foo_BAR").toString())
        @AssertThrows(LanguageRange.fromUnix("en@arabic.UTF-8").toString())
        //TODO need more test
    }
}

@Test
class LocaleTest {
    @TestCase
    func categoryTagList() {
        @Assert(collectArray<TagsIteratorItem>(Locale.new("cs-CZ,messages=en-GB,time=de-DE,collate=en-US").toTags().iterator()),[TagsIteratorItem(Option<String>.None, LanguageRange("cs-CZ")),TagsIteratorItem(Some("messages"), LanguageRange("en-GB")),TagsIteratorItem(Some("time"), LanguageRange("de-DE")),TagsIteratorItem(Some("collate"), LanguageRange("en-US"))])
    }

    @TestCase
    func localeSimple() {
        @Assert("en-US",Locale.new("en-US").toString())
        @Assert("zh-Hant",Locale.new("zh-hant").toString())
        @Assert("de-*",Locale.new("de-*").toString())
        @AssertThrows(Locale.new("invalid!"))
        @AssertThrows(Locale.new("hı-İN"))
    }

    @TestCase
    func localeList() {
        @Assert("cs-CZ,en-GB,en,*",Locale.new("cs-cz,en-gb,en,*").toString())
        @Assert("cs-CZ,engrish",Locale.new("cs-cz,engrish").toString())
        @AssertThrows(Locale.new("cs-cz,hı-İN"))
    }

    @TestCase
    func localeCategory() {
        @Assert("cs-CZ,messages=en-GB",Locale.new("cs-CZ,messages=en-GB").toString())
        @Assert("zh-Hant,time=ja-JP,measurement=en-US",Locale.new("zh-hant,TIME=ja-jp,meaSURement=en-US").toString())
        @AssertThrows(Locale.new("messages=pl"))
        @AssertThrows(Locale.new("numeric=de,fr-FR"))
    }

    @TestCase
    func localeDups() {
        @Assert("cs-CZ,en,de-AT",Locale.new("cs-CZ,en,de-AT,en").toString())
        @Assert("en-US,en",Locale.new("en-us,en-US,EN,eN-Us,en").toString())
    }

    @TestCase
    func localeCategoryDup() {
        @Assert("cs-CZ",Locale.new("cs-CZ,messages=cs-CZ,time=cs-cz,collate=CS-cz").toString())
        @Assert("de-AT,en-AU",Locale.new("de-AT,en-AU,messages=de-AT").toString())
        @Assert("de-AT,en-AU,messages=en-AU",Locale.new("de-AT,en-AU,messages=en-AU").toString())
        @Assert("hi-IN,time=en-IN",Locale.new("hi-IN,time=en-IN,TIME=EN-in,TiMe=En-iN").toString())
    }

    @TestCase
    func tagListFor() {
        let locale = Locale.new("cs-CZ,messages=en-GB,time=de-DE,sk-SK,pl-PL")
        @Assert(collectArray<TagsForIteratorItem>(locale.toTagsFor("messages").iterator()),[
            LanguageRange("en-GB"),
            LanguageRange("cs-CZ"),
            LanguageRange("sk-SK"),
            LanguageRange("pl-PL")])
        @Assert(collectArray<TagsForIteratorItem>(locale.toTagsFor("time").iterator()),[
            LanguageRange("de-DE"),
            LanguageRange("cs-CZ"),
            LanguageRange("sk-SK"),
            LanguageRange("pl-PL")])
    }
}