#!/usr/bin/env python3
"""
Kanadská teritoria a provincie - MaxMind formát
"""

def create_canada_regions():
    """Vytvoř kompletní seznam kanadských provincií a teritorií"""
    
    print("🇨🇦 Zpracovávám kanadské provincie a teritoria...")
    
    # Kompletní seznam kanadských provincií a teritorií s MaxMind kódy
    canada_regions = {
        # Provincie
        'AB': {
            'name': 'Alberta',
            'type': 'Province',
            'capital': 'Edmonton',
            'region': 'Western Canada'
        },
        'BC': {
            'name': 'British Columbia', 
            'type': 'Province',
            'capital': 'Victoria',
            'region': 'Western Canada'
        },
        'MB': {
            'name': 'Manitoba',
            'type': 'Province', 
            'capital': 'Winnipeg',
            'region': 'Central Canada'
        },
        'NB': {
            'name': 'New Brunswick',
            'type': 'Province',
            'capital': 'Fredericton', 
            'region': 'Atlantic Canada'
        },
        'NL': {
            'name': 'Newfoundland and Labrador',
            'type': 'Province',
            'capital': 'St. John\'s',
            'region': 'Atlantic Canada'
        },
        'NS': {
            'name': 'Nova Scotia',
            'type': 'Province',
            'capital': 'Halifax',
            'region': 'Atlantic Canada'
        },
        'ON': {
            'name': 'Ontario',
            'type': 'Province',
            'capital': 'Toronto',
            'region': 'Central Canada'
        },
        'PE': {
            'name': 'Prince Edward Island',
            'type': 'Province',
            'capital': 'Charlottetown',
            'region': 'Atlantic Canada'
        },
        'QC': {
            'name': 'Quebec',
            'type': 'Province',
            'capital': 'Quebec City',
            'region': 'Central Canada'
        },
        'SK': {
            'name': 'Saskatchewan',
            'type': 'Province',
            'capital': 'Regina',
            'region': 'Western Canada'
        },
        
        # Teritoria
        'NT': {
            'name': 'Northwest Territories',
            'type': 'Territory',
            'capital': 'Yellowknife',
            'region': 'Northern Canada'
        },
        'NU': {
            'name': 'Nunavut',
            'type': 'Territory',
            'capital': 'Iqaluit',
            'region': 'Northern Canada'
        },
        'YT': {
            'name': 'Yukon Territory',
            'type': 'Territory',
            'capital': 'Whitehorse',
            'region': 'Northern Canada'
        }
    }
    
    processed_regions = []
    
    for code, info in canada_regions.items():
        processed_regions.append([
            'CA',  # Country code
            code,  # Province/Territory code
            info['name'],
            info['type'],
            info['capital'],
            info['region'],
            'MaxMind Canada'
        ])
    
    # Seřaď podle typu (provincie první, pak teritoria) a pak podle názvu
    processed_regions.sort(key=lambda x: (x[3], x[2]))
    
    print(f"✅ Zpracováno {len(processed_regions)} kanadských regionů")
    print(f"   - Provincie: {len([r for r in processed_regions if r[3] == 'Province'])}")
    print(f"   - Teritoria: {len([r for r in processed_regions if r[3] == 'Territory'])}")
    
    return processed_regions

def create_basic_format():
    """Vytvoř základní formát jen s kódy a názvy"""
    
    canada_basic = {
        'AB': 'Alberta',
        'BC': 'British Columbia',
        'MB': 'Manitoba', 
        'NB': 'New Brunswick',
        'NL': 'Newfoundland and Labrador',
        'NS': 'Nova Scotia',
        'ON': 'Ontario',
        'PE': 'Prince Edward Island',
        'QC': 'Quebec',
        'SK': 'Saskatchewan',
        'NT': 'Northwest Territories',
        'NU': 'Nunavut',
        'YT': 'Yukon Territory'
    }
    
    basic_regions = []
    for code, name in canada_basic.items():
        region_type = 'Territory' if code in ['NT', 'NU', 'YT'] else 'Province'
        basic_regions.append([code, name, region_type, 'MaxMind Standard'])
    
    # Seřaď podle typu a názvu
    basic_regions.sort(key=lambda x: (x[2], x[1]))
    
    return basic_regions

def create_ssv_formats():
    """Vytvoř různé SSV formáty"""
    
    # Extended format
    extended_regions = create_canada_regions()
    extended_headers = [
        'Country_Code',
        'Region_Code',
        'Region_Name', 
        'Region_Type',
        'Capital',
        'Region_Group',
        'MaxMind_Database'
    ]
    
    # Basic format
    basic_regions = create_basic_format()
    basic_headers = [
        'Region_Code',
        'Region_Name',
        'Region_Type', 
        'MaxMind_Database'
    ]
    
    # Create extended SSV
    print("💾 Vytvářím rozšířený formát...")
    extended_lines = [';'.join(extended_headers)]
    
    for region in extended_regions:
        clean_region = []
        for cell in region:
            clean_cell = str(cell).replace(';', ',').replace('"', "'")
            clean_region.append(clean_cell)
        extended_lines.append(';'.join(clean_region))
    
    with open('maxmind_CA_extended_SSV.csv', 'w', encoding='utf-8') as f:
        f.write('\n'.join(extended_lines))
    
    # Create basic SSV
    print("💾 Vytvářím základní formát...")
    basic_lines = [';'.join(basic_headers)]
    
    for region in basic_regions:
        clean_region = []
        for cell in region:
            clean_cell = str(cell).replace(';', ',').replace('"', "'")
            clean_region.append(clean_cell)
        basic_lines.append(';'.join(clean_region))
    
    with open('maxmind_CA_basic_SSV.csv', 'w', encoding='utf-8') as f:
        f.write('\n'.join(basic_lines))
    
    # Create territories only
    print("💾 Vytvářím formát jen pro teritoria...")
    territories_only = [region for region in basic_regions if region[2] == 'Territory']
    territories_lines = [';'.join(basic_headers)]
    
    for territory in territories_only:
        clean_territory = []
        for cell in territory:
            clean_cell = str(cell).replace(';', ',').replace('"', "'")
            clean_territory.append(clean_cell)
        territories_lines.append(';'.join(clean_territory))
    
    with open('maxmind_CA_territories_only_SSV.csv', 'w', encoding='utf-8') as f:
        f.write('\n'.join(territories_lines))
    
    print("💾 Uloženy soubory:")
    print("   - maxmind_CA_extended_SSV.csv (kompletní)")
    print("   - maxmind_CA_basic_SSV.csv (základní)")
    print("   - maxmind_CA_territories_only_SSV.csv (jen teritoria)")
    
    return extended_lines, basic_lines, territories_lines

def main():
    """Hlavní funkce"""
    
    print("🇨🇦 KANADSKÉ PROVINCIE A TERITORIA - MAXMIND FORMÁT")
    print("=" * 60)
    
    # Create all formats
    extended_lines, basic_lines, territories_lines = create_ssv_formats()
    
    print("\n" + "=" * 60)
    print("✅ HOTOVO!")
    print("=" * 60)
    
    print(f"\n📊 VYTVOŘENÉ SOUBORY:")
    print("1. 🏛️  maxmind_CA_extended_SSV.csv    (s hlavními městy a regiony)")
    print("2. 📋 maxmind_CA_basic_SSV.csv        (jen kódy a názvy)")
    print("3. 🏔️  maxmind_CA_territories_only_SSV.csv (jen 3 teritoria)")
    
    print(f"\n📈 STATISTIKY:")
    print(f"   Celkem regionů: {len(basic_lines) - 1}")  # -1 for header
    print(f"   Provincie: 10")
    print(f"   Teritoria: 3")
    
    print(f"\n🎯 KOPÍROVÁNÍ DO GOOGLE SHEETS:")
    print("1. Vyber soubor podle potřeby")
    print("2. Otevři soubor")
    print("3. Ctrl+A → Ctrl+C")
    print("4. Google Sheets → A1 → Ctrl+V")
    print("5. ✅ Sloupce se rozdělí podle středníků!")
    
    print(f"\n📋 NÁHLED základního formátu:")
    print("=" * 40)
    for i, line in enumerate(basic_lines[:8]):
        if i == 0:
            print(f"HLAVIČKY: {line.replace(';', ' | ')}")
            print("-" * 40)
        else:
            parts = line.split(';')
            print(f"{i}. {parts[0]} - {parts[1]} ({parts[2]})")
    
    print(f"\n📋 NÁHLED jen teritorií:")
    print("=" * 40)
    for i, line in enumerate(territories_lines):
        if i == 0:
            continue  # Skip header
        else:
            parts = line.split(';')
            print(f"🏔️  {parts[0]} - {parts[1]}")
    
    print(f"\n🌟 DOPORUČUJI:")
    print("   - Pro kompletní: maxmind_CA_extended_SSV.csv")
    print("   - Pro jen kódy: maxmind_CA_basic_SSV.csv")
    print("   - Pro teritoria: maxmind_CA_territories_only_SSV.csv")

if __name__ == "__main__":
    main()