use parse_display::{Display, FromStr};

use super::Country;

use CountryAlpha2::*;
use CountryAlpha3::*;

struct CountriesList<'a> {
    countries: &'a [Country],
}

impl<'a> CountriesList<'a> {
    #[inline]
    const fn new(countries: &'a [Country]) -> Self {
        Self { countries }
    }

    #[inline]
    pub const fn country_by_numeric(&self, numeric: u16) -> Option<Country> {
        let mut low = 0;
        let mut high = self.countries.len() - 1;

        while low <= high {
            let mid = (low + high) / 2;
            let mid_val = self.countries[mid].numeric();

            if mid_val < numeric {
                low = mid + 1;
            } else if mid_val > numeric {
                high = mid - 1;
            } else {
                return Some(self.countries[mid]);
            }
        }

        None
    }

    #[inline]
    pub const fn country_by_alpha2(&self, alpha2: CountryAlpha2) -> Country {
        self.countries[alpha2.internal_offset()]
    }

    #[inline]
    pub const fn country_by_alpha3(&self, alpha3: CountryAlpha3) -> Country {
        self.countries[alpha3.internal_offset()]
    }
}

// NOTE: This is static as that reduces the size of the binary and makes it faster.
//       Order is important, as it is used for binary search by the `Country` numeric.
//       Also, alpha 2 and alpha 3 codes are sorted alphabetically but the values are
//       offsets into the array for fast lookup from the `CountryAlpha2` and `CountryAlpha3`
//       enums.
static COUNTRIES: CountriesList = CountriesList::new(&[
    Country::new(AF, AFG, 004),
    Country::new(AL, ALB, 008),
    Country::new(AQ, ATA, 010),
    Country::new(DZ, DZA, 012),
    Country::new(AS, ASM, 016),
    Country::new(AD, AND, 020),
    Country::new(AO, AGO, 024),
    Country::new(AG, ATG, 028),
    Country::new(AZ, AZE, 031),
    Country::new(AR, ARG, 032),
    Country::new(AU, AUS, 036),
    Country::new(AT, AUT, 040),
    Country::new(BS, BHS, 044),
    Country::new(BH, BHR, 048),
    Country::new(BD, BGD, 050),
    Country::new(AM, ARM, 051),
    Country::new(BB, BRB, 052),
    Country::new(BE, BEL, 056),
    Country::new(BM, BMU, 060),
    Country::new(BT, BTN, 064),
    Country::new(BO, BOL, 068),
    Country::new(BA, BIH, 070),
    Country::new(BW, BWA, 072),
    Country::new(BV, BVT, 074),
    Country::new(BR, BRA, 076),
    Country::new(BZ, BLZ, 084),
    Country::new(IO, IOT, 086),
    Country::new(SB, SLB, 090),
    Country::new(VG, VGB, 092),
    Country::new(BN, BRN, 096),
    Country::new(BG, BGR, 100),
    Country::new(MM, MMR, 104),
    Country::new(BI, BDI, 108),
    Country::new(BY, BLR, 112),
    Country::new(KH, KHM, 116),
    Country::new(CM, CMR, 120),
    Country::new(CA, CAN, 124),
    Country::new(CV, CPV, 132),
    Country::new(KY, CYM, 136),
    Country::new(CF, CAF, 140),
    Country::new(LK, LKA, 144),
    Country::new(TD, TCD, 148),
    Country::new(CL, CHL, 152),
    Country::new(CN, CHN, 156),
    Country::new(TW, TWN, 158),
    Country::new(CX, CXR, 162),
    Country::new(CC, CCK, 166),
    Country::new(CO, COL, 170),
    Country::new(KM, COM, 174),
    Country::new(YT, MYT, 175),
    Country::new(CG, COG, 178),
    Country::new(CD, COD, 180),
    Country::new(CK, COK, 184),
    Country::new(CR, CRI, 188),
    Country::new(HR, HRV, 191),
    Country::new(CU, CUB, 192),
    Country::new(CY, CYP, 196),
    Country::new(CZ, CZE, 203),
    Country::new(BJ, BEN, 204),
    Country::new(DK, DNK, 208),
    Country::new(DM, DMA, 212),
    Country::new(DO, DOM, 214),
    Country::new(EC, ECU, 218),
    Country::new(SV, SLV, 222),
    Country::new(GQ, GNQ, 226),
    Country::new(ER, ERI, 232),
    Country::new(ET, ETH, 231),
    Country::new(EE, EST, 233),
    Country::new(FO, FRO, 234),
    Country::new(FK, FLK, 238),
    Country::new(GS, SGS, 239),
    Country::new(FJ, FJI, 242),
    Country::new(FI, FIN, 246),
    Country::new(AX, ALA, 248),
    Country::new(FR, FRA, 250),
    Country::new(GF, GUF, 254),
    Country::new(PF, PYF, 258),
    Country::new(TF, ATF, 260),
    Country::new(DJ, DJI, 262),
    Country::new(GA, GAB, 266),
    Country::new(GE, GEO, 268),
    Country::new(GM, GMB, 270),
    Country::new(PS, PSE, 275),
    Country::new(DE, DEU, 276),
    Country::new(GH, GHA, 288),
    Country::new(GI, GIB, 292),
    Country::new(KI, KIR, 296),
    Country::new(GR, GRC, 300),
    Country::new(GL, GRL, 304),
    Country::new(GD, GRD, 308),
    Country::new(GP, GLP, 312),
    Country::new(GU, GUM, 316),
    Country::new(GT, GTM, 320),
    Country::new(GN, GIN, 324),
    Country::new(GY, GUY, 328),
    Country::new(HT, HTI, 332),
    Country::new(HM, HMD, 334),
    Country::new(VA, VAT, 336),
    Country::new(HN, HND, 340),
    Country::new(HK, HKG, 344),
    Country::new(HU, HUN, 348),
    Country::new(IS, ISL, 352),
    Country::new(IN, IND, 356),
    Country::new(ID, IDN, 360),
    Country::new(IR, IRN, 364),
    Country::new(IQ, IRQ, 368),
    Country::new(IE, IRL, 372),
    Country::new(IL, ISR, 376),
    Country::new(IT, ITA, 380),
    Country::new(CI, CIV, 384),
    Country::new(JM, JAM, 388),
    Country::new(JP, JPN, 392),
    Country::new(KZ, KAZ, 398),
    Country::new(JO, JOR, 400),
    Country::new(KE, KEN, 404),
    Country::new(KP, PRK, 408),
    Country::new(KR, KOR, 410),
    Country::new(KW, KWT, 414),
    Country::new(KG, KGZ, 417),
    Country::new(LA, LAO, 418),
    Country::new(LB, LBN, 422),
    Country::new(LS, LSO, 426),
    Country::new(LV, LVA, 428),
    Country::new(LR, LBR, 430),
    Country::new(LY, LBY, 434),
    Country::new(LI, LIE, 438),
    Country::new(LT, LTU, 440),
    Country::new(LU, LUX, 442),
    Country::new(MO, MAC, 446),
    Country::new(MG, MDG, 450),
    Country::new(MW, MWI, 454),
    Country::new(MY, MYS, 458),
    Country::new(MV, MDV, 462),
    Country::new(ML, MLI, 466),
    Country::new(MT, MLT, 470),
    Country::new(MQ, MTQ, 474),
    Country::new(MR, MRT, 478),
    Country::new(MU, MUS, 480),
    Country::new(MX, MEX, 484),
    Country::new(MC, MCO, 492),
    Country::new(MN, MNG, 496),
    Country::new(MD, MDA, 498),
    Country::new(ME, MNE, 499),
    Country::new(MS, MSR, 500),
    Country::new(MA, MAR, 504),
    Country::new(MZ, MOZ, 508),
    Country::new(OM, OMN, 512),
    Country::new(NA, NAM, 516),
    Country::new(NR, NRU, 520),
    Country::new(NP, NPL, 524),
    Country::new(NL, NLD, 528),
    Country::new(CW, CUW, 531),
    Country::new(AW, ABW, 533),
    Country::new(SX, SXM, 534),
    Country::new(BQ, BES, 535),
    Country::new(NC, NCL, 540),
    Country::new(VU, VUT, 548),
    Country::new(NZ, NZL, 554),
    Country::new(NI, NIC, 558),
    Country::new(NE, NER, 562),
    Country::new(NG, NGA, 566),
    Country::new(NU, NIU, 570),
    Country::new(NF, NFK, 574),
    Country::new(NO, NOR, 578),
    Country::new(MP, MNP, 580),
    Country::new(UM, UMI, 581),
    Country::new(FM, FSM, 583),
    Country::new(MH, MHL, 584),
    Country::new(PW, PLW, 585),
    Country::new(PK, PAK, 586),
    Country::new(PA, PAN, 591),
    Country::new(PG, PNG, 598),
    Country::new(PY, PRY, 600),
    Country::new(PE, PER, 604),
    Country::new(PH, PHL, 608),
    Country::new(PN, PCN, 612),
    Country::new(PL, POL, 616),
    Country::new(PT, PRT, 620),
    Country::new(GW, GNB, 624),
    Country::new(TL, TLS, 626),
    Country::new(PR, PRI, 630),
    Country::new(QA, QAT, 634),
    Country::new(RE, REU, 638),
    Country::new(RO, ROU, 642),
    Country::new(RU, RUS, 643),
    Country::new(RW, RWA, 646),
    Country::new(BL, BLM, 652),
    Country::new(SH, SHN, 654),
    Country::new(KN, KNA, 659),
    Country::new(LC, LCA, 662),
    Country::new(AI, AIA, 660),
    Country::new(MF, MAF, 663),
    Country::new(PM, SPM, 666),
    Country::new(VC, VCT, 670),
    Country::new(SM, SMR, 674),
    Country::new(ST, STP, 678),
    Country::new(SA, SAU, 682),
    Country::new(SN, SEN, 686),
    Country::new(RS, SRB, 688),
    Country::new(SC, SYC, 690),
    Country::new(SL, SLE, 694),
    Country::new(SG, SGP, 702),
    Country::new(SK, SVK, 703),
    Country::new(VN, VNM, 704),
    Country::new(SI, SVN, 705),
    Country::new(SO, SOM, 706),
    Country::new(ZA, ZAF, 710),
    Country::new(ZW, ZWE, 716),
    Country::new(ES, ESP, 724),
    Country::new(SS, SSD, 728),
    Country::new(SD, SDN, 729),
    Country::new(EH, ESH, 732),
    Country::new(SR, SUR, 740),
    Country::new(SJ, SJM, 744),
    Country::new(SZ, SWZ, 748),
    Country::new(SE, SWE, 752),
    Country::new(CH, CHE, 756),
    Country::new(SY, SYR, 760),
    Country::new(TJ, TJK, 762),
    Country::new(TH, THA, 764),
    Country::new(TG, TGO, 768),
    Country::new(TK, TKL, 772),
    Country::new(TO, TON, 776),
    Country::new(AE, ARE, 784),
    Country::new(TN, TUN, 788),
    Country::new(TT, TTO, 780),
    Country::new(TR, TUR, 792),
    Country::new(TM, TKM, 795),
    Country::new(TC, TCA, 796),
    Country::new(TV, TUV, 798),
    Country::new(UG, UGA, 800),
    Country::new(UA, UKR, 804),
    Country::new(MK, MKD, 807),
    Country::new(EG, EGY, 818),
    Country::new(GB, GBR, 826),
    Country::new(GG, GGY, 831),
    Country::new(JE, JEY, 832),
    Country::new(IM, IMN, 833),
    Country::new(TZ, TZA, 834),
    Country::new(US, USA, 840),
    Country::new(VI, VIR, 850),
    Country::new(BF, BFA, 854),
    Country::new(UY, URY, 858),
    Country::new(UZ, UZB, 860),
    Country::new(VE, VEN, 862),
    Country::new(WF, WLF, 876),
    Country::new(WS, WSM, 882),
    Country::new(YE, YEM, 887),
    Country::new(ZM, ZMB, 894),
]);

impl From<CountryAlpha2> for Country {
    #[inline]
    fn from(value: CountryAlpha2) -> Self {
        COUNTRIES.country_by_alpha2(value)
    }
}

impl From<CountryAlpha3> for Country {
    #[inline]
    fn from(value: CountryAlpha3) -> Self {
        COUNTRIES.country_by_alpha3(value)
    }
}

impl TryFrom<u16> for Country {
    type Error = ();

    #[inline]
    fn try_from(value: u16) -> Result<Self, Self::Error> {
        COUNTRIES.country_by_numeric(value).ok_or(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display, FromStr)]
pub enum CountryAlpha2 {
    AF = 0,
    AL = 1,
    AQ = 2,
    DZ = 3,
    AS = 4,
    AD = 5,
    AO = 6,
    AG = 7,
    AZ = 8,
    AR = 9,
    AU = 10,
    AT = 11,
    BS = 12,
    BH = 13,
    BD = 14,
    AM = 15,
    BB = 16,
    BE = 17,
    BM = 18,
    BT = 19,
    BO = 20,
    BA = 21,
    BW = 22,
    BV = 23,
    BR = 24,
    BZ = 25,
    IO = 26,
    SB = 27,
    VG = 28,
    BN = 29,
    BG = 30,
    MM = 31,
    BI = 32,
    BY = 33,
    KH = 34,
    CM = 35,
    CA = 36,
    CV = 37,
    KY = 38,
    CF = 39,
    LK = 40,
    TD = 41,
    CL = 42,
    CN = 43,
    TW = 44,
    CX = 45,
    CC = 46,
    CO = 47,
    KM = 48,
    YT = 49,
    CG = 50,
    CD = 51,
    CK = 52,
    CR = 53,
    HR = 54,
    CU = 55,
    CY = 56,
    CZ = 57,
    BJ = 58,
    DK = 59,
    DM = 60,
    DO = 61,
    EC = 62,
    SV = 63,
    GQ = 64,
    ER = 65,
    ET = 66,
    EE = 67,
    FO = 68,
    FK = 69,
    GS = 70,
    FJ = 71,
    FI = 72,
    AX = 73,
    FR = 74,
    GF = 75,
    PF = 76,
    TF = 77,
    DJ = 78,
    GA = 79,
    GE = 80,
    GM = 81,
    PS = 82,
    DE = 83,
    GH = 84,
    GI = 85,
    KI = 86,
    GR = 87,
    GL = 88,
    GD = 89,
    GP = 90,
    GU = 91,
    GT = 92,
    GN = 93,
    GY = 94,
    HT = 95,
    HM = 96,
    VA = 97,
    HN = 98,
    HK = 99,
    HU = 100,
    IS = 101,
    IN = 102,
    ID = 103,
    IR = 104,
    IQ = 105,
    IE = 106,
    IL = 107,
    IT = 108,
    CI = 109,
    JM = 110,
    JP = 111,
    KZ = 112,
    JO = 113,
    KE = 114,
    KP = 115,
    KR = 116,
    KW = 117,
    KG = 118,
    LA = 119,
    LB = 120,
    LS = 121,
    LV = 122,
    LR = 123,
    LY = 124,
    LI = 125,
    LT = 126,
    LU = 127,
    MO = 128,
    MG = 129,
    MW = 130,
    MY = 131,
    MV = 132,
    ML = 133,
    MT = 134,
    MQ = 135,
    MR = 136,
    MU = 137,
    MX = 138,
    MC = 139,
    MN = 140,
    MD = 141,
    ME = 142,
    MS = 143,
    MA = 144,
    MZ = 145,
    OM = 146,
    NA = 147,
    NR = 148,
    NP = 149,
    NL = 150,
    CW = 151,
    AW = 152,
    SX = 153,
    BQ = 154,
    NC = 155,
    VU = 156,
    NZ = 157,
    NI = 158,
    NE = 159,
    NG = 160,
    NU = 161,
    NF = 162,
    NO = 163,
    MP = 164,
    UM = 165,
    FM = 166,
    MH = 167,
    PW = 168,
    PK = 169,
    PA = 170,
    PG = 171,
    PY = 172,
    PE = 173,
    PH = 174,
    PN = 175,
    PL = 176,
    PT = 177,
    GW = 178,
    TL = 179,
    PR = 180,
    QA = 181,
    RE = 182,
    RO = 183,
    RU = 184,
    RW = 185,
    BL = 186,
    SH = 187,
    KN = 188,
    LC = 189,
    AI = 190,
    MF = 191,
    PM = 192,
    VC = 193,
    SM = 194,
    ST = 195,
    SA = 196,
    SN = 197,
    RS = 198,
    SC = 199,
    SL = 200,
    SG = 201,
    SK = 202,
    VN = 203,
    SI = 204,
    SO = 205,
    ZA = 206,
    ZW = 207,
    ES = 208,
    SS = 209,
    SD = 210,
    EH = 211,
    SR = 212,
    SJ = 213,
    SZ = 214,
    SE = 215,
    CH = 216,
    SY = 217,
    TJ = 218,
    TH = 219,
    TG = 220,
    TK = 221,
    TO = 222,
    AE = 223,
    TN = 224,
    TT = 225,
    TR = 226,
    TM = 227,
    TC = 228,
    TV = 229,
    UG = 230,
    UA = 231,
    MK = 232,
    EG = 233,
    GB = 234,
    GG = 235,
    JE = 236,
    IM = 237,
    TZ = 238,
    US = 239,
    VI = 240,
    BF = 241,
    UY = 242,
    UZ = 243,
    VE = 244,
    WF = 245,
    WS = 246,
    YE = 247,
    ZM = 248,
}

impl CountryAlpha2 {
    #[inline]
    pub(crate) const fn internal_offset(&self) -> usize {
        *self as usize
    }
}

impl From<CountryAlpha3> for CountryAlpha2 {
    #[inline]
    fn from(value: CountryAlpha3) -> Self {
        COUNTRIES.country_by_alpha3(value).alpha2()
    }
}

impl From<CountryAlpha2> for u16 {
    #[inline]
    fn from(value: CountryAlpha2) -> Self {
        COUNTRIES.country_by_alpha2(value).numeric()
    }
}

impl TryFrom<u16> for CountryAlpha2 {
    type Error = ();

    #[inline]
    fn try_from(value: u16) -> Result<Self, Self::Error> {
        COUNTRIES.country_by_numeric(value)
        .map(|country| country.alpha2())
        .ok_or(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display, FromStr)]
pub enum CountryAlpha3 {
    AFG = 0,
    ALB = 1,
    ATA = 2,
    DZA = 3,
    ASM = 4,
    AND = 5,
    AGO = 6,
    ATG = 7,
    AZE = 8,
    ARG = 9,
    AUS = 10,
    AUT = 11,
    BHS = 12,
    BHR = 13,
    BGD = 14,
    ARM = 15,
    BRB = 16,
    BEL = 17,
    BMU = 18,
    BTN = 19,
    BOL = 20,
    BIH = 21,
    BWA = 22,
    BVT = 23,
    BRA = 24,
    BLZ = 25,
    IOT = 26,
    SLB = 27,
    VGB = 28,
    BRN = 29,
    BGR = 30,
    MMR = 31,
    BDI = 32,
    BLR = 33,
    KHM = 34,
    CMR = 35,
    CAN = 36,
    CPV = 37,
    CYM = 38,
    CAF = 39,
    LKA = 40,
    TCD = 41,
    CHL = 42,
    CHN = 43,
    TWN = 44,
    CXR = 45,
    CCK = 46,
    COL = 47,
    COM = 48,
    MYT = 49,
    COG = 50,
    COD = 51,
    COK = 52,
    CRI = 53,
    HRV = 54,
    CUB = 55,
    CYP = 56,
    CZE = 57,
    BEN = 58,
    DNK = 59,
    DMA = 60,
    DOM = 61,
    ECU = 62,
    SLV = 63,
    GNQ = 64,
    ERI = 65,
    ETH = 66,
    EST = 67,
    FRO = 68,
    FLK = 69,
    SGS = 70,
    FJI = 71,
    FIN = 72,
    ALA = 73,
    FRA = 74,
    GUF = 75,
    PYF = 76,
    ATF = 77,
    DJI = 78,
    GAB = 79,
    GEO = 80,
    GMB = 81,
    PSE = 82,
    DEU = 83,
    GHA = 84,
    GIB = 85,
    KIR = 86,
    GRC = 87,
    GRL = 88,
    GRD = 89,
    GLP = 90,
    GUM = 91,
    GTM = 92,
    GIN = 93,
    GUY = 94,
    HTI = 95,
    HMD = 96,
    VAT = 97,
    HND = 98,
    HKG = 99,
    HUN = 100,
    ISL = 101,
    IND = 102,
    IDN = 103,
    IRN = 104,
    IRQ = 105,
    IRL = 106,
    ISR = 107,
    ITA = 108,
    CIV = 109,
    JAM = 110,
    JPN = 111,
    KAZ = 112,
    JOR = 113,
    KEN = 114,
    PRK = 115,
    KOR = 116,
    KWT = 117,
    KGZ = 118,
    LAO = 119,
    LBN = 120,
    LSO = 121,
    LVA = 122,
    LBR = 123,
    LBY = 124,
    LIE = 125,
    LTU = 126,
    LUX = 127,
    MAC = 128,
    MDG = 129,
    MWI = 130,
    MYS = 131,
    MDV = 132,
    MLI = 133,
    MLT = 134,
    MTQ = 135,
    MRT = 136,
    MUS = 137,
    MEX = 138,
    MCO = 139,
    MNG = 140,
    MDA = 141,
    MNE = 142,
    MSR = 143,
    MAR = 144,
    MOZ = 145,
    OMN = 146,
    NAM = 147,
    NRU = 148,
    NPL = 149,
    NLD = 150,
    CUW = 151,
    ABW = 152,
    SXM = 153,
    BES = 154,
    NCL = 155,
    VUT = 156,
    NZL = 157,
    NIC = 158,
    NER = 159,
    NGA = 160,
    NIU = 161,
    NFK = 162,
    NOR = 163,
    MNP = 164,
    UMI = 165,
    FSM = 166,
    MHL = 167,
    PLW = 168,
    PAK = 169,
    PAN = 170,
    PNG = 171,
    PRY = 172,
    PER = 173,
    PHL = 174,
    PCN = 175,
    POL = 176,
    PRT = 177,
    GNB = 178,
    TLS = 179,
    PRI = 180,
    QAT = 181,
    REU = 182,
    ROU = 183,
    RUS = 184,
    RWA = 185,
    BLM = 186,
    SHN = 187,
    KNA = 188,
    LCA = 189,
    AIA = 190,
    MAF = 191,
    SPM = 192,
    VCT = 193,
    SMR = 194,
    STP = 195,
    SAU = 196,
    SEN = 197,
    SRB = 198,
    SYC = 199,
    SLE = 200,
    SGP = 201,
    SVK = 202,
    VNM = 203,
    SVN = 204,
    SOM = 205,
    ZAF = 206,
    ZWE = 207,
    ESP = 208,
    SSD = 209,
    SDN = 210,
    ESH = 211,
    SUR = 212,
    SJM = 213,
    SWZ = 214,
    SWE = 215,
    CHE = 216,
    SYR = 217,
    TJK = 218,
    THA = 219,
    TGO = 220,
    TKL = 221,
    TON = 222,
    ARE = 223,
    TUN = 224,
    TTO = 225,
    TUR = 226,
    TKM = 227,
    TCA = 228,
    TUV = 229,
    UGA = 230,
    UKR = 231,
    MKD = 232,
    EGY = 233,
    GBR = 234,
    GGY = 235,
    JEY = 236,
    IMN = 237,
    TZA = 238,
    USA = 239,
    VIR = 240,
    BFA = 241,
    URY = 242,
    UZB = 243,
    VEN = 244,
    WLF = 245,
    WSM = 246,
    YEM = 247,
    ZMB = 248,
}

impl CountryAlpha3 {
    #[inline]
    pub(crate) const fn internal_offset(&self) -> usize {
        *self as usize
    }
}

impl From<CountryAlpha2> for CountryAlpha3 {
    #[inline]
    fn from(value: CountryAlpha2) -> Self {
        COUNTRIES.country_by_alpha2(value).alpha3()
    }
}

impl From<CountryAlpha3> for u16 {
    #[inline]
    fn from(value: CountryAlpha3) -> Self {
        COUNTRIES.country_by_alpha3(value).numeric()
    }
}

impl TryFrom<u16> for CountryAlpha3 {
    type Error = ();

    #[inline]
    fn try_from(value: u16) -> Result<Self, Self::Error> {
        COUNTRIES.country_by_numeric(value)
        .map(|country| country.alpha3())
        .ok_or(())
    }
}

#[cfg(test)]
mod test {
    use super::*;

    extern crate alloc;
    use alloc::string::ToString;

    use core::str::FromStr;

    #[test]
    fn test_alpha2_from_alpha3() {
        let alpha3 = CountryAlpha3::AND;
        let alpha2 = CountryAlpha2::from(alpha3);
        assert_eq!(alpha2, CountryAlpha2::AD);
    }

    #[test]
    fn test_alpha2_from_numeric() {
        let alpha2 = CountryAlpha2::AD;
        let numeric = Country::from(alpha2).numeric();
        let alpha2_from_numeric = CountryAlpha2::try_from(numeric).unwrap();
        assert_eq!(alpha2, alpha2_from_numeric);
    }

    #[test]
    fn test_alpha3_from_alpha2() {
        let alpha2 = CountryAlpha2::AD;
        let alpha3 = CountryAlpha3::from(alpha2);
        assert_eq!(alpha3, CountryAlpha3::AND);
    }

    #[test]
    fn test_alpha3_from_numeric() {
        let alpha3 = CountryAlpha3::AND;
        let numeric = Country::from(alpha3).numeric();
        let alpha3_from_numeric = CountryAlpha3::try_from(numeric).unwrap();
        assert_eq!(alpha3, alpha3_from_numeric);
    }

    #[test]
    fn test_numeric_from_alpha2() {
        let alpha2 = CountryAlpha2::AD;
        let numeric = u16::from(alpha2);
        assert_eq!(numeric, 020);
    }

    #[test]
    fn test_numeric_from_alpha3() {
        let alpha3 = CountryAlpha3::AND;
        let numeric = u16::from(alpha3);
        assert_eq!(numeric, 020);
    }

    #[test]
    fn test_country_from_alpha2() {
        let alpha2 = CountryAlpha2::AD;
        let country = Country::from(alpha2);
        assert_eq!(country.alpha2(), alpha2);
    }

    #[test]
    fn test_country_from_alpha3() {
        let alpha3 = CountryAlpha3::AND;
        let country = Country::from(alpha3);
        assert_eq!(country.alpha3(), alpha3);
    }

    #[test]
    fn test_country_from_numeric() {
        let numeric = 020;
        let country = Country::try_from(numeric).unwrap();
        assert_eq!(country.numeric(), numeric);
    }

    #[test]
    fn test_alpha2_from_str() {
        let alpha2 = CountryAlpha2::AD;
        let alpha2_from_str = CountryAlpha2::from_str("AD").unwrap();
        assert_eq!(alpha2, alpha2_from_str);
    }

    #[test]
    fn test_alpha3_from_str() {
        let alpha3 = CountryAlpha3::AND;
        let alpha3_from_str = CountryAlpha3::from_str("AND").unwrap();
        assert_eq!(alpha3, alpha3_from_str);
    }

    #[test]
    fn test_alpha2_to_string() {
        let alpha2 = CountryAlpha2::AD;
        let alpha2_string = alpha2.to_string();
        assert_eq!(alpha2_string, "AD");
    }

    #[test]
    fn test_alpha3_to_string() {
        let alpha3 = CountryAlpha3::AND;
        let alpha3_string = alpha3.to_string();
        assert_eq!(alpha3_string, "AND");
    }
}