// Synchronous browser filesystem adapter for the production MapViewport.
// Tile positions follow the existing Linux adapter and shared Mercator helpers.
// No page controls, overlays, labels, fonts or styles are defined here.
#include "ui/widgets/map/map_tiles.h"
#include "ui_map_runtime/map_tiles/map_tile_geometry.h"
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <string>

static uint8_t source_id = 0;
static bool contours = false;
static bool missing = false;
static double world_size(int z) { return std::ldexp(256.0, z); }
static double world_x(double lon, int z) { return (lon + 180.0) / 360.0 * world_size(z); }
static double world_y(double lat, int z)
{
    lat = std::clamp(lat, -85.05112878, 85.05112878);
    const double s = std::sin(lat * M_PI / 180.0);
    return (.5 - std::log((1 + s) / (1 - s)) / (4 * M_PI)) * world_size(z);
}
static void world_geo(double x, double y, int z, double& lat, double& lon)
{
    const double size = world_size(z);
    lon = x / size * 360 - 180;
    lat = std::atan(std::sinh(M_PI * (1 - 2 * y / size))) * 180 / M_PI;
}
void normalize_tile(int z, int& x, int& y) { ui::map_tiles::normalizeTile(z, x, y); }
void latLngToTile(double lat, double lon, int zoom, int& x, int& y) { ui::map_tiles::latLngToTile(lat, lon, zoom, x, y); }
void tileToLatLng(int x, int y, int zoom, double& lat, double& lon) { world_geo(x * 256.0, y * 256.0, zoom, lat, lon); }
void tileToPixel(int x, int y, int, int& px, int& py)
{
    px = x * 256;
    py = y * 256;
}
uint8_t sanitize_map_source(uint8_t source) { return source < 3 ? source : 0; }
const char* map_source_label(uint8_t source) { return source == 1 ? "Terrain" : source == 2 ? "Satellite"
                                                                                            : "OSM"; }
bool build_base_tile_path(int z, int x, int y, uint8_t source, char* out, size_t n)
{
    const char* key = source == 1 ? "terrain" : source == 2 ? "satellite"
                                                            : "osm";
    return std::snprintf(out, n, "A:/maps/base/%s/%d/%d/%d.png", key, z, x, y) > 0;
}
bool build_contour_tile_path(int z, int x, int y, char* out, size_t n) { return std::snprintf(out, n, "A:/maps/contour/major-50/%d/%d/%d.png", z, x, y) > 0; }
static bool exists(const char* path)
{
    FILE* f = std::fopen(path + 2, "rb");
    if (!f) return false;
    std::fclose(f);
    return true;
}
bool base_tile_available(int z, int x, int y, uint8_t source)
{
    char path[180];
    build_base_tile_path(z, x, y, source, path, sizeof(path));
    return exists(path);
}
bool map_source_directory_available(uint8_t source) { return source < 3; }
bool contour_directory_available() { return false; }
bool take_missing_tile_notice(uint8_t* out)
{
    if (out) *out = source_id;
    const bool result = missing;
    missing = false;
    return result;
}
void set_map_render_options(uint8_t source, bool contour)
{
    source_id = sanitize_map_source(source);
    contours = contour;
}
void update_map_anchor(TileContext& c, double lat, double lon, int zoom, int pan_x, int pan_y, bool fix)
{
    if (!c.anchor || !c.map_container) return;
    auto& a = *c.anchor;
    a.valid = fix;
    if (!fix) return;
    a.z = zoom;
    a.n = std::ldexp(1.0, zoom);
    int x, y;
    latLngToTile(lat, lon, zoom, x, y);
    a.gps_tile_x = x;
    a.gps_tile_y = y;
    a.gps_global_pixel_x = static_cast<int>(std::lround(world_x(lon, zoom)));
    a.gps_global_pixel_y = static_cast<int>(std::lround(world_y(lat, zoom)));
    a.gps_tile_pixel_x = x * 256;
    a.gps_tile_pixel_y = y * 256;
    a.gps_offset_x = a.gps_global_pixel_x - a.gps_tile_pixel_x;
    a.gps_offset_y = a.gps_global_pixel_y - a.gps_tile_pixel_y;
    a.gps_tile_screen_x = lv_obj_get_width(c.map_container) / 2 - a.gps_offset_x + pan_x;
    a.gps_tile_screen_y = lv_obj_get_height(c.map_container) / 2 - a.gps_offset_y + pan_y;
}
bool gps_screen_pos(const TileContext& c, double lat, double lon, int& x, int& y)
{
    if (!c.anchor || !c.anchor->valid) return false;
    const auto& a = *c.anchor;
    double dx = world_x(lon, a.z) - a.gps_global_pixel_x;
    const double size = world_size(a.z);
    if (dx > size / 2) dx -= size;
    if (dx < -size / 2) dx += size;
    x = std::lround(a.gps_tile_screen_x + a.gps_offset_x + dx);
    y = std::lround(a.gps_tile_screen_y + a.gps_offset_y + world_y(lat, a.z) - a.gps_global_pixel_y);
    return true;
}
bool tile_screen_pos_xyz(const TileContext& c, int x, int y, int z, int& sx, int& sy)
{
    if (!c.anchor || !c.anchor->valid || c.anchor->z != z) return false;
    const auto& a = *c.anchor;
    int dx = x - a.gps_tile_x, n = 1 << z;
    if (dx > n / 2) dx -= n;
    if (dx < -n / 2) dx += n;
    sx = a.gps_tile_screen_x + dx * 256;
    sy = a.gps_tile_screen_y + (y - a.gps_tile_y) * 256;
    return true;
}
void get_screen_center_lat_lng(const TileContext& c, double& lat, double& lon)
{
    if (!c.anchor || !c.anchor->valid)
    {
        lat = lon = 0;
        return;
    }
    const auto& a = *c.anchor;
    world_geo(a.gps_global_pixel_x + lv_obj_get_width(c.map_container) / 2 - a.gps_tile_screen_x - a.gps_offset_x, a.gps_global_pixel_y + lv_obj_get_height(c.map_container) / 2 - a.gps_tile_screen_y - a.gps_offset_y, a.z, lat, lon);
}
bool tile_in_rect(int x, int y, int w, int h, int margin) { return x < w + margin && y < h + margin && x + 256 > -margin && y + 256 > -margin; }
void cleanup_tiles(TileContext& c)
{
    if (c.tiles)
    {
        for (auto& t : *c.tiles)
        {
            if (t.img_obj) lv_obj_delete(t.img_obj);
            if (t.contour_obj) lv_obj_delete(t.contour_obj);
        }
        c.tiles->clear();
    }
    if (c.has_map_data) *c.has_map_data = false;
    if (c.has_visible_map_data) *c.has_visible_map_data = false;
}
void calculate_required_tiles(TileContext& c, double lat, double lon, int z, int px, int py, bool fix)
{
    update_map_anchor(c, lat, lon, z, px, py, fix);
    if (!c.tiles || !c.anchor || !c.anchor->valid) return;
    bool any = false;
    for (auto& t : *c.tiles)
    {
        t.visible = false;
        if (t.img_obj) lv_obj_add_flag(t.img_obj, LV_OBJ_FLAG_HIDDEN);
    }
    const int w = lv_obj_get_width(c.map_container), h = lv_obj_get_height(c.map_container);
    double center_lat, center_lon;
    get_screen_center_lat_lng(c, center_lat, center_lon);
    for (auto xy : ui::map_tiles::tilesAround(center_lat, center_lon, z, w / 256 + 2, h / 256 + 2))
    {
        int sx, sy;
        if (!tile_screen_pos_xyz(c, xy.x, xy.y, z, sx, sy) || !tile_in_rect(sx, sy, w, h, 0)) continue;
        auto found = std::find_if(c.tiles->begin(), c.tiles->end(), [&](const auto& t)
                                  { return t.x == xy.x && t.y == xy.y && t.z == z && t.map_source == source_id; });
        if (found == c.tiles->end())
        {
            MapTile t;
            t.x = xy.x;
            t.y = xy.y;
            t.z = z;
            t.map_source = source_id;
            t.has_png_file = base_tile_available(z, t.x, t.y, source_id);
            c.tiles->push_back(t);
            found = c.tiles->end() - 1;
        }
        auto& tile = *found;
        if (!tile.has_png_file)
        {
            missing = true;
            continue;
        }
        if (!tile.img_obj)
        {
            tile.img_obj = lv_image_create(c.map_container);
            char path[180];
            build_base_tile_path(z, tile.x, tile.y, source_id, path, sizeof(path));
            lv_image_set_src(tile.img_obj, path);
        }
        lv_obj_set_pos(tile.img_obj, sx, sy);
        lv_obj_clear_flag(tile.img_obj, LV_OBJ_FLAG_HIDDEN);
        tile.visible = true;
        any = true;
    }
    if (c.has_map_data) *c.has_map_data = any;
    if (c.has_visible_map_data) *c.has_visible_map_data = any;
}
void tile_loader_step(TileContext&) {}
void init_tile_context(TileContext& c, lv_obj_t* obj, MapAnchor* anchor, std::vector<MapTile>* tiles, ui::map_tiles::MapTileRenderQueue* queue, bool* has, bool* visible) { c = {obj, anchor, tiles, queue, has, visible}; }
void release_tile_context(TileContext& c)
{
    cleanup_tiles(c);
    c = {};
}