#!/usr/bin/env python3
import sqlite3
import json
import subprocess
import sys
from pathlib import Path

def read_gdal_bounds(raster):
    """Legge i bounds WGS84 dal TIFF usando gdalinfo -json."""
    info = subprocess.check_output(["gdalinfo", "-json", raster])
    info = json.loads(info)

    if "wgs84Extent" in info:
        coords = info["wgs84Extent"]["coordinates"][0]
        minlon, minlat = coords[0]
        maxlon, maxlat = coords[2]
    else:
        cc = info["cornerCoordinates"]
        minlon, minlat = cc["lowerLeft"]
        maxlon, maxlat = cc["upperRight"]

    # Normalizzazione latitudine
    if minlat > maxlat:
        minlat, maxlat = maxlat, minlat

    return (minlon, minlat, maxlon, maxlat)


def open_mbtiles(mbtiles):
    """Apre MBTiles e garantisce che la tabella metadata esista."""
    conn = sqlite3.connect(mbtiles)
    cur = conn.cursor()

    # Verifica tabella tiles
    cur.execute("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='tiles';")
    if cur.fetchone()[0] == 0:
        raise RuntimeError("La tabella 'tiles' non esiste nell'MBTiles.")

    # Conta tile
    cur.execute("SELECT COUNT(*) FROM tiles;")
    tile_count = cur.fetchone()[0]
    if tile_count == 0:
        raise RuntimeError("La tabella 'tiles' è vuota.")

    # Zoom min/max
    cur.execute("SELECT MIN(zoom_level), MAX(zoom_level) FROM tiles;")
    minzoom, maxzoom = cur.fetchone()

    # Crea metadata se manca
    cur.execute("""
        CREATE TABLE IF NOT EXISTS metadata (
            name TEXT PRIMARY KEY,
            value TEXT
        );
    """)

    # Leggi metadata esistenti
    cur.execute("SELECT name, value FROM metadata;")
    metadata = dict(cur.fetchall())

    return conn, cur, tile_count, minzoom, maxzoom, metadata


def write_metadata(cur, name, value):
    cur.execute("REPLACE INTO metadata (name, value) VALUES (?, ?)", (name, value))


def main():
    if len(sys.argv) < 3:
        print("Uso: python3 set_mbtiles_metadata.py <raster.tif> <file.mbtiles> [name]")
        sys.exit(1)

    raster = Path(sys.argv[1])
    mbtiles = Path(sys.argv[2])
    layer_name = sys.argv[3] if len(sys.argv) > 3 else mbtiles.stem

    if not raster.exists():
        print(f"Raster non trovato: {raster}")
        sys.exit(1)
    if not mbtiles.exists():
        print(f"MBTiles non trovato: {mbtiles}")
        sys.exit(1)

    print("== Impostazione metadata MBTiles ==")

    # 1) Bounds dal TIFF
    minlon, minlat, maxlon, maxlat = read_gdal_bounds(raster)
    bounds = f"{minlon:.6f},{minlat:.6f},{maxlon:.6f},{maxlat:.6f}"
    print(f"Bounds TIFF: {bounds}")

    # 2) Lettura MBTiles
    conn, cur, tile_count, minzoom, maxzoom, metadata = open_mbtiles(mbtiles)

    print(f"Tile count: {tile_count}")
    print(f"Zoom effettivi: {minzoom}..{maxzoom}")

    # 3) Center
    ctr_lon = (minlon + maxlon) / 2
    ctr_lat = (minlat + maxlat) / 2
    ctr_zoom = (minzoom + maxzoom) // 2
    center = f"{ctr_lon:.6f},{ctr_lat:.6f},{ctr_zoom}"

    # 4) Scrittura metadata
    write_metadata(cur, "name", layer_name)
    write_metadata(cur, "format", "png")
    write_metadata(cur, "type", "overlay")
    write_metadata(cur, "scheme", "xyz")
    write_metadata(cur, "bounds", bounds)
    write_metadata(cur, "center", center)
    write_metadata(cur, "minzoom", str(minzoom))
    write_metadata(cur, "maxzoom", str(maxzoom))

    conn.commit()
    conn.close()

    print("\n== Metadata scritti correttamente ==")
    print(f"name: {layer_name}")
    print(f"format: png")
    print(f"type: overlay")
    print(f"scheme: xyz")
    print(f"bounds: {bounds}")
    print(f"center: {center}")
    print(f"minzoom: {minzoom}")
    print(f"maxzoom: {maxzoom}")
    print("\nMBTiles ora è pronto per TileServer GL.")


if __name__ == "__main__":
    main()