import os
from pathlib import Path
import json
import random
import csv
from collections import defaultdict

areas = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 
         'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}

data_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/")
output_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/splits/")
output_path.mkdir(parents=True, exist_ok=True)

# Configuration
SEED = 42
TRAIN_RATIO = 0.8
VAL_RATIO = 0.1
TEST_RATIO = 0.1

assert abs(TRAIN_RATIO + VAL_RATIO + TEST_RATIO - 1.0) < 1e-6, "Ratios must sum to 1.0"

random.seed(SEED)

print("=" * 80)
print("MatchGeo-DEM Stratified Split Generator")
print(f"Train: {TRAIN_RATIO:.0%} | Val: {VAL_RATIO:.0%} | Test: {TEST_RATIO:.0%}")
print(f"Random seed: {SEED}")
print("=" * 80)

all_tiles = []

# Collect all tiles per city
for location in sorted(areas):
    tiles_dir = data_path / location / "tiles"

    if not tiles_dir.exists():
        print(f"⚠️  {location}: No tiles directory found")
        continue

    city_tiles = []
    for tile_file in sorted(tiles_dir.iterdir()):
        if tile_file.suffix == '.tif':
            tile_id = tile_file.stem
            city_tiles.append({
                "tile_id": tile_id,
                "city": location,
                "file": str(tile_file.relative_to(data_path.parent))
            })

    print(f"📁 {location}: {len(city_tiles)} tiles collected")
    all_tiles.extend(city_tiles)

print(f"\n📊 Total tiles: {len(all_tiles)}")

# Group by city
city_groups = defaultdict(list)
for tile in all_tiles:
    city_groups[tile["city"]].append(tile)

# Stratified split: ensure each city is represented in each split
train_tiles = []
val_tiles = []
test_tiles = []

for city, tiles in sorted(city_groups.items()):
    n = len(tiles)
    random.shuffle(tiles)

    n_train = max(1, int(n * TRAIN_RATIO))
    n_val = max(1, int(n * VAL_RATIO))
    # Test gets the remainder
    n_test = n - n_train - n_val

    # Adjust if test is too small
    if n_test < 1 and n > 2:
        n_train -= 1
        n_test = 1

    city_train = tiles[:n_train]
    city_val = tiles[n_train:n_train + n_val]
    city_test = tiles[n_train + n_val:]

    train_tiles.extend(city_train)
    val_tiles.extend(city_val)
    test_tiles.extend(city_test)

    print(f"\n📁 {city}:")
    print(f"   Total: {n} | Train: {len(city_train)} | Val: {len(city_val)} | Test: {len(city_test)}")

# Shuffle again within each split
random.shuffle(train_tiles)
random.shuffle(val_tiles)
random.shuffle(test_tiles)

print(f"\n{'='*80}")
print(f"📊 FINAL SPLIT SIZES:")
print(f"   Train: {len(train_tiles)} tiles ({len(train_tiles)/len(all_tiles):.1%})")
print(f"   Val:   {len(val_tiles)} tiles ({len(val_tiles)/len(all_tiles):.1%})")
print(f"   Test:  {len(test_tiles)} tiles ({len(test_tiles)/len(all_tiles):.1%})")
print(f"{'='*80}")

# City distribution per split
print(f"\n📊 CITY DISTRIBUTION PER SPLIT:")
for split_name, split_tiles in [("Train", train_tiles), ("Val", val_tiles), ("Test", test_tiles)]:
    city_counts = defaultdict(int)
    for tile in split_tiles:
        city_counts[tile["city"]] += 1
    print(f"\n{split_name}:")
    for city in sorted(city_counts.keys()):
        print(f"   {city}: {city_counts[city]} tiles")

# Write CSV files
def write_split_csv(tiles, filepath):
    with open(filepath, 'w', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=["tile_id", "city", "file"])
        writer.writeheader()
        for tile in tiles:
            writer.writerow(tile)

write_split_csv(train_tiles, output_path / "train.csv")
write_split_csv(val_tiles, output_path / "validation.csv")
write_split_csv(test_tiles, output_path / "test.csv")

print(f"\n✅ Splits saved to:")
print(f"   {output_path / 'train.csv'}")
print(f"   {output_path / 'validation.csv'}")
print(f"   {output_path / 'test.csv'}")

# Save JSON manifest
split_manifest = {
    "seed": SEED,
    "ratios": {"train": TRAIN_RATIO, "validation": VAL_RATIO, "test": TEST_RATIO},
    "total_tiles": len(all_tiles),
    "splits": {
        "train": len(train_tiles),
        "validation": len(val_tiles),
        "test": len(test_tiles)
    },
    "files": {
        "train": str(output_path / "train.csv"),
        "validation": str(output_path / "validation.csv"),
        "test": str(output_path / "test.csv")
    }
}

with open(output_path / "split_manifest.json", 'w') as f:
    json.dump(split_manifest, f, indent=2)

print(f"\n✅ Split manifest saved to: {output_path / 'split_manifest.json'}")