const std = @import("std");
const WeatherProvider = @import("Provider.zig");
const Coordinates = @import("../Coordinates.zig");
const types = @import("types.zig");
const Cache = @import("../cache/Cache.zig");

const MetNo = @This();

const MetNoOpenWeatherEntry = struct { []const u8, types.WeatherCode };
// symbol codes: https://github.com/metno/weathericons/tree/main/weather
// they also have _day, _night and _polartwilight variants
//
// Openweathermap weather condition codes:
//   https://openweathermap.org/weather-conditions
const weather_code_entries = [_]MetNoOpenWeatherEntry{
    // zig fmt: off
            .{ "clearsky",                     .clear                      },
            .{ "cloudy",                       .clouds_overcast            },
            .{ "fair",                         .clouds_few                 },
            .{ "fog",                          .fog                        },
            .{ "heavyrain",                    .rain_heavy                 },
            .{ "heavyrainandthunder",          .thunderstorm_heavy_rain    },
            .{ "heavyrainshowers",             .thunderstorm_drizzle       },
            .{ "heavyrainshowersandthunder",   .thunderstorm_heavy_drizzle },
            .{ "heavysleet",                   .sleet                      },
            .{ "heavysleetandthunder",         .thunderstorm_heavy_rain    },
            .{ "heavysleetshowers",            .sleet_shower               },
            .{ "heavysleetshowersandthunder",  .thunderstorm_heavy_drizzle },
            .{ "heavysnow",                    .snow_heavy                 },
            .{ "heavysnowandthunder",          .thunderstorm_heavy         },
            .{ "heavysnowshowers",             .snow_shower_heavy          },
            .{ "heavysnowshowersandthunder",   .thunderstorm_heavy         },
            .{ "lightrain",                    .rain_light                 },
            .{ "lightrainandthunder",          .thunderstorm_light_rain    },
            .{ "lightrainshowers",             .rain_shower_light          },
            .{ "lightrainshowersandthunder",   .thunderstorm_light_rain    },
            .{ "lightsleet",                   .sleet_shower_light         },
            .{ "lightsleetandthunder",         .thunderstorm_light         },
            .{ "lightsleetshowers",            .sleet_shower_light         },
            .{ "lightsnow",                    .snow_light                 },
            .{ "lightsnowandthunder",          .thunderstorm_light         },
            .{ "lightsnowshowers",             .snow_shower_light          },
            .{ "lightssleetshowersandthunder", .thunderstorm_light         },
            .{ "lightssnowshowersandthunder",  .thunderstorm_light         },
            .{ "partlycloudy",                 .clouds_few                 },
            .{ "rain",                         .rain_moderate              },
            .{ "rainandthunder",               .thunderstorm_rain          },
            .{ "rainshowers",                  .rain_shower                },
            .{ "rainshowersandthunder",        .thunderstorm_drizzle       },
            .{ "sleet",                        .sleet                      },
            .{ "sleetandthunder",              .thunderstorm               },
            .{ "sleetshowers",                 .sleet_shower               },
            .{ "sleetshowersandthunder",       .thunderstorm_drizzle       },
            .{ "snow",                         .snow                       },
            .{ "snowandthunder",               .thunderstorm               },
            .{ "snowshowers",                  .snow_shower                },
            .{ "snowshowersandthunder",        .thunderstorm               },
    // zig fmt: on
    };

const WeatherCodeMap = std.StaticStringMap(types.WeatherCode);
const weather_code_map = WeatherCodeMap.initComptime(weather_code_entries);

allocator: std.mem.Allocator,

pub fn init(allocator: std.mem.Allocator) !MetNo {
    return MetNo{
        .allocator = allocator,
    };
}

pub fn provider(self: *MetNo, cache: *Cache) WeatherProvider {
    return .{
        .ptr = self,
        .cache = cache,
        .vtable = &.{
            .fetchRaw = fetchRaw,
            .parse = parse,
            .deinit = deinitProvider,
        },
    };
}

fn fetchRaw(ptr: *anyopaque, allocator: std.mem.Allocator, coords: Coordinates) ![]const u8 {
    const self: *MetNo = @ptrCast(@alignCast(ptr));

    const url = try std.fmt.allocPrint(
        self.allocator,
        "https://api.met.no/weatherapi/locationforecast/2.0/compact?lat={d:.4}&lon={d:.4}",
        .{ coords.latitude, coords.longitude },
    );
    defer self.allocator.free(url);

    // Fetch weather data from met.no API
    var client = std.http.Client{ .allocator = self.allocator };
    defer client.deinit();

    const uri = try std.Uri.parse(url);

    var response_buf: [1024 * 1024]u8 = undefined;
    var writer = std.Io.Writer.fixed(&response_buf);
    const result = try client.fetch(.{
        .location = .{ .uri = uri },
        .method = .GET,
        .response_writer = &writer,
        .extra_headers = &.{
            .{ .name = "User-Agent", .value = "wttr.in-zig/1.0 github.com/chubin/wttr.in" },
        },
    });

    if (result.status != .ok) {
        return error.WeatherApiFailed;
    }

    const response_body = response_buf[0..writer.end];
    return try allocator.dupe(u8, response_body);
}

fn parse(ptr: *anyopaque, allocator: std.mem.Allocator, raw: []const u8) !types.WeatherData {
    _ = ptr;

    // Parse JSON response
    const parsed = try std.json.parseFromSlice(
        std.json.Value,
        allocator,
        raw,
        .{},
    );
    defer parsed.deinit();

    // Extract coordinates from the response (we don't have them passed in)
    const geometry = parsed.value.object.get("geometry") orelse return error.InvalidResponse;
    const coordinates = geometry.object.get("coordinates") orelse return error.InvalidResponse;
    const lon: f64 = coordinates.array.items[0].float;
    const lat: f64 = coordinates.array.items[1].float;
    const coords = Coordinates{ .latitude = lat, .longitude = lon };

    return try parseMetNoResponse(allocator, coords, parsed.value);
}

fn deinitProvider(ptr: *anyopaque) void {
    const self: *MetNo = @ptrCast(@alignCast(ptr));
    self.deinit();
}

pub fn deinit(self: *MetNo) void {
    _ = self;
}

fn parseMetNoResponse(allocator: std.mem.Allocator, coords: Coordinates, json: std.json.Value) !types.WeatherData {
    const properties = json.object.get("properties") orelse return error.InvalidResponse;
    const timeseries = properties.object.get("timeseries") orelse return error.InvalidResponse;

    if (timeseries.array.items.len == 0) return error.InvalidResponse;

    const current = timeseries.array.items[0];
    const data = current.object.get("data") orelse return error.InvalidResponse;
    const instant = data.object.get("instant") orelse return error.InvalidResponse;
    const details = instant.object.get("details") orelse return error.InvalidResponse;

    const temp_c: f32 = @floatCast(details.object.get("air_temperature").?.float);
    const humidity: u8 = @intFromFloat(details.object.get("relative_humidity").?.float);
    const wind_speed_ms = details.object.get("wind_speed").?.float;
    const wind_kph: f32 = @floatCast(wind_speed_ms * 3.6);
    const pressure_mb: f32 = @floatCast(details.object.get("air_pressure_at_sea_level").?.float);

    // Get weather symbol
    const next_1h = data.object.get("next_1_hours");
    const symbol_code = if (next_1h) |n1h|
        n1h.object.get("summary").?.object.get("symbol_code").?.string
    else
        "clearsky_day";

    // Get wind direction
    const wind_from_deg = details.object.get("wind_from_direction");
    const wind_dir = if (wind_from_deg) |deg|
        degreeToDirection(@as(f32, @floatCast(deg.float)))
    else
        "N";

    // Parse forecast days from timeseries
    const forecast = try parseForecastDays(allocator, timeseries.array.items);

    const feels_like_c = temp_c; // TODO: Calculate wind chill

    return types.WeatherData{
        .location = try std.fmt.allocPrint(allocator, "{d:.4},{d:.4}", .{ coords.latitude, coords.longitude }),
        .current = .{
            .temp_c = temp_c,
            .temp_f = temp_c * 9.0 / 5.0 + 32.0,
            .feels_like_c = feels_like_c,
            .feels_like_f = feels_like_c * 9.0 / 5.0 + 32.0,
            .condition = try allocator.dupe(u8, symbolCodeToCondition(symbol_code)),
            .weather_code = symbolCodeToWeatherCode(symbol_code),
            .humidity = humidity,
            .wind_kph = wind_kph,
            .wind_dir = try allocator.dupe(u8, wind_dir),
            .pressure_mb = pressure_mb,
            .precip_mm = 0.0,
        },
        .forecast = forecast,
        .allocator = allocator,
    };
}

fn clearHourlyForecast(allocator: std.mem.Allocator, forecast: *std.ArrayList(types.HourlyForecast)) void {
    for (forecast.items) |h| {
        allocator.free(h.time);
        allocator.free(h.condition);
    }
    forecast.clearRetainingCapacity();
}

fn parseForecastDays(allocator: std.mem.Allocator, timeseries: []std.json.Value) ![]types.ForecastDay {
    var days: std.ArrayList(types.ForecastDay) = .empty;
    errdefer days.deinit(allocator);

    var current_date: ?[]const u8 = null;
    var day_temps: std.ArrayList(f32) = .empty;
    defer day_temps.deinit(allocator);
    var day_hourly: std.ArrayList(types.HourlyForecast) = .empty;
    defer {
        for (day_hourly.items) |h| {
            allocator.free(h.time);
            allocator.free(h.condition);
        }
        day_hourly.deinit(allocator);
    }
    var day_all_hours: std.ArrayList(types.HourlyForecast) = .empty;
    defer {
        for (day_all_hours.items) |h| {
            allocator.free(h.time);
            allocator.free(h.condition);
        }
        day_all_hours.deinit(allocator);
    }
    var day_symbol: ?[]const u8 = null;

    for (timeseries) |entry| {
        const time_str = entry.object.get("time").?.string;
        const date = time_str[0..10];
        const hour = time_str[11..13];

        const data = entry.object.get("data") orelse continue;
        const instant = data.object.get("instant") orelse continue;
        const details_obj = instant.object.get("details") orelse continue;
        const temp: f32 = @floatCast(details_obj.object.get("air_temperature").?.float);
        const wind_ms = details_obj.object.get("wind_speed") orelse continue;
        const wind_kph: f32 = @floatCast(wind_ms.float * 3.6);

        if (current_date == null or !std.mem.eql(u8, current_date.?, date)) {
            // Save previous day if exists
            if (current_date != null and day_temps.items.len > 0) {
                var max_temp: f32 = day_temps.items[0];
                var min_temp: f32 = day_temps.items[0];
                for (day_temps.items) |t| {
                    if (t > max_temp) max_temp = t;
                    if (t < min_temp) min_temp = t;
                }

                const symbol = day_symbol orelse "clearsky_day";

                // Use preferred times if we have 4, otherwise pick 4 evenly spaced from all hours
                const hourly_slice: []types.HourlyForecast = blk: {
                    if (day_hourly.items.len >= 4) {
                        const hrs = try day_hourly.toOwnedSlice(allocator);
                        clearHourlyForecast(allocator, &day_all_hours);
                        break :blk hrs;
                    }

                    clearHourlyForecast(allocator, &day_all_hours);

                    if (day_all_hours.items.len < 4)
                        break :blk try day_all_hours.toOwnedSlice(allocator);
                    // Pick 4 evenly spaced entries from day_all_hours
                    if (day_all_hours.items.len >= 4) {
                        const step = day_all_hours.items.len / 4;
                        var selected: std.ArrayList(types.HourlyForecast) = .empty;
                        try selected.append(allocator, day_all_hours.items[0]);
                        try selected.append(allocator, day_all_hours.items[step]);
                        try selected.append(allocator, day_all_hours.items[step * 2]);
                        try selected.append(allocator, day_all_hours.items[step * 3]);
                        const hrs = try selected.toOwnedSlice(allocator);

                        // Free the rest
                        for (day_all_hours.items, 0..) |h, i| {
                            if (i != 0 and i != step and i != step * 2 and i != step * 3) {
                                allocator.free(h.time);
                                allocator.free(h.condition);
                            }
                        }
                        day_all_hours.clearRetainingCapacity();
                        break :blk hrs;
                    }
                    break :blk try day_all_hours.toOwnedSlice(allocator);
                };

                try days.append(allocator, .{
                    .date = try allocator.dupe(u8, current_date.?),
                    .max_temp_c = max_temp,
                    .min_temp_c = min_temp,
                    .condition = try allocator.dupe(u8, symbolCodeToCondition(symbol)),
                    .weather_code = symbolCodeToWeatherCode(symbol),
                    .hourly = hourly_slice,
                });

                if (days.items.len >= 3) break;
            }

            // Start new day
            current_date = date;
            day_temps.clearRetainingCapacity();
            day_all_hours.clearRetainingCapacity();
            day_symbol = null;
        }

        try day_temps.append(allocator, temp);

        // Collect ALL hourly forecasts
        const next_1h = data.object.get("next_1_hours");
        if (next_1h) |n1h| {
            const symbol_code = n1h.object.get("summary").?.object.get("symbol_code").?.string;
            const precip = if (n1h.object.get("details")) |det| blk: {
                if (det.object.get("precipitation_amount")) |p| {
                    break :blk @as(f32, @floatCast(p.float));
                }
                break :blk @as(f32, 0.0);
            } else 0.0;

            try day_all_hours.append(allocator, .{
                .time = try allocator.dupe(u8, time_str[11..16]),
                .temp_c = temp,
                .feels_like_c = temp,
                .condition = try allocator.dupe(u8, symbolCodeToCondition(symbol_code)),
                .weather_code = symbolCodeToWeatherCode(symbol_code),
                .wind_kph = wind_kph,
                .precip_mm = precip,
            });
        }

        // Collect preferred hourly forecasts for 06:00, 12:00, 18:00, 00:00
        if (std.mem.eql(u8, hour, "06") or std.mem.eql(u8, hour, "12") or
            std.mem.eql(u8, hour, "18") or std.mem.eql(u8, hour, "00")) {
            if (next_1h) |n1h| {
                const symbol_code = n1h.object.get("summary").?.object.get("symbol_code").?.string;
                const precip = if (n1h.object.get("details")) |det| blk: {
                    if (det.object.get("precipitation_amount")) |p| {
                        break :blk @as(f32, @floatCast(p.float));
                    }
                    break :blk @as(f32, 0.0);
                } else 0.0;

                try day_hourly.append(allocator, .{
                    .time = try allocator.dupe(u8, time_str[11..16]),
                    .temp_c = temp,
                    .feels_like_c = temp,
                    .condition = try allocator.dupe(u8, symbolCodeToCondition(symbol_code)),
                    .weather_code = symbolCodeToWeatherCode(symbol_code),
                    .wind_kph = wind_kph,
                    .precip_mm = precip,
                });
            }
        }

        // Get symbol for the day
        if (day_symbol == null) {
            const next_6h = data.object.get("next_6_hours");
            if (next_6h) |n6h| {
                if (n6h.object.get("summary")) |summary| {
                    day_symbol = summary.object.get("symbol_code").?.string;
                }
            }
        }
    }

    return days.toOwnedSlice(allocator);
}

fn symbolCodeToWeatherCode(symbol: []const u8) types.WeatherCode {
    var it = std.mem.splitScalar(u8, symbol, '_');
    const metno_weather_code = it.next().?;
    const variant = it.next();
    _ = variant; // discard day/night/polar twilight for now
    return weather_code_map.get(metno_weather_code) orelse .unknown;
}

fn symbolCodeToCondition(symbol: []const u8) []const u8 {
    var it = std.mem.splitScalar(u8, symbol, '_');
    const metno_weather_code = it.next().?;
    if (std.mem.eql(u8, metno_weather_code, "clearsky")) return "Clear";
    if (std.mem.eql(u8, metno_weather_code, "partlycloudy")) return "Partly cloudy";
    if (std.mem.eql(u8, metno_weather_code, "fair")) return "Fair";
    if (std.mem.eql(u8, metno_weather_code, "cloudy")) return "Cloudy";
    if (std.mem.eql(u8, metno_weather_code, "fog")) return "Fog";
    if (std.mem.eql(u8, metno_weather_code, "thunder")) return "Thunderstorm";
    if (std.mem.eql(u8, metno_weather_code, "rain")) return "Rain";
    if (std.mem.eql(u8, metno_weather_code, "sleet")) return "Sleet";
    if (std.mem.eql(u8, metno_weather_code, "snow")) return "Snow";
    return "Unknown";
}

fn degreeToDirection(deg: f32) []const u8 {
    const normalized = @mod(deg + 22.5, 360.0);
    const idx: usize = @intFromFloat(normalized / 45.0);
    const directions = [_][]const u8{ "N", "NE", "E", "SE", "S", "SW", "W", "NW" };
    return directions[@min(idx, 7)];
}

test "degreeToDirection" {
    try std.testing.expectEqualStrings("N", degreeToDirection(0));
    try std.testing.expectEqualStrings("NE", degreeToDirection(45));
    try std.testing.expectEqualStrings("E", degreeToDirection(90));
    try std.testing.expectEqualStrings("SE", degreeToDirection(135));
    try std.testing.expectEqualStrings("S", degreeToDirection(180));
    try std.testing.expectEqualStrings("SW", degreeToDirection(225));
    try std.testing.expectEqualStrings("W", degreeToDirection(270));
    try std.testing.expectEqualStrings("NW", degreeToDirection(315));
}

test "symbolCodeToWeatherCode" {
    try std.testing.expectEqual(types.WeatherCode.clear, symbolCodeToWeatherCode("clearsky_day"));
    try std.testing.expectEqual(types.WeatherCode.clouds_few, symbolCodeToWeatherCode("fair_night"));
    try std.testing.expectEqual(types.WeatherCode.clouds_overcast, symbolCodeToWeatherCode("cloudy"));
    try std.testing.expectEqual(types.WeatherCode.rain_light, symbolCodeToWeatherCode("lightrain"));
    try std.testing.expectEqual(types.WeatherCode.snow, symbolCodeToWeatherCode("snow"));
}

test "parseForecastDays extracts 3 days" {
    const allocator = std.testing.allocator;

    const json_str =
        \\{"properties":{"timeseries":[
        \\  {"time":"2025-12-20T00:00:00Z","data":{"instant":{"details":{"air_temperature":10.0,"wind_speed":5.0}},"next_6_hours":{"summary":{"symbol_code":"clearsky_day"}}}},
        \\  {"time":"2025-12-20T06:00:00Z","data":{"instant":{"details":{"air_temperature":15.0,"wind_speed":6.0}},"next_1_hours":{"summary":{"symbol_code":"clearsky_day"}}}},
        \\  {"time":"2025-12-20T12:00:00Z","data":{"instant":{"details":{"air_temperature":20.0,"wind_speed":7.0}},"next_1_hours":{"summary":{"symbol_code":"clearsky_day"}}}},
        \\  {"time":"2025-12-20T18:00:00Z","data":{"instant":{"details":{"air_temperature":12.0,"wind_speed":5.0}},"next_1_hours":{"summary":{"symbol_code":"clearsky_day"}}}},
        \\  {"time":"2025-12-21T00:00:00Z","data":{"instant":{"details":{"air_temperature":8.0,"wind_speed":8.0}},"next_6_hours":{"summary":{"symbol_code":"rain"}},"next_1_hours":{"summary":{"symbol_code":"rain"}}}},
        \\  {"time":"2025-12-21T12:00:00Z","data":{"instant":{"details":{"air_temperature":14.0,"wind_speed":10.0}},"next_1_hours":{"summary":{"symbol_code":"rain"}}}},
        \\  {"time":"2025-12-22T00:00:00Z","data":{"instant":{"details":{"air_temperature":5.0,"wind_speed":4.0}},"next_6_hours":{"summary":{"symbol_code":"snow"}},"next_1_hours":{"summary":{"symbol_code":"snow"}}}},
        \\  {"time":"2025-12-22T12:00:00Z","data":{"instant":{"details":{"air_temperature":7.0,"wind_speed":3.0}},"next_1_hours":{"summary":{"symbol_code":"snow"}}}},
        \\  {"time":"2025-12-23T00:00:00Z","data":{"instant":{"details":{"air_temperature":6.0,"wind_speed":2.0}}}}
        \\]}}
    ;

    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, json_str, .{});
    defer parsed.deinit();

    const properties = parsed.value.object.get("properties").?;
    const timeseries = properties.object.get("timeseries").?;

    const forecast = try parseForecastDays(allocator, timeseries.array.items);
    defer {
        for (forecast) |day| {
            allocator.free(day.date);
            allocator.free(day.condition);
            for (day.hourly) |hour| {
                allocator.free(hour.time);
                allocator.free(hour.condition);
            }
            allocator.free(day.hourly);
        }
        allocator.free(forecast);
    }

    try std.testing.expectEqual(@as(usize, 3), forecast.len);
    try std.testing.expectEqualStrings("2025-12-20", forecast[0].date);
    try std.testing.expectEqual(@as(f32, 20.0), forecast[0].max_temp_c);
    try std.testing.expectEqual(@as(f32, 10.0), forecast[0].min_temp_c);
    try std.testing.expectEqual(types.WeatherCode.clear, forecast[0].weather_code);
}

test "parseForecastDays handles empty timeseries" {
    const allocator = std.testing.allocator;
    const empty: []std.json.Value = &.{};
    const forecast = try parseForecastDays(allocator, empty);
    defer allocator.free(forecast);
    try std.testing.expectEqual(@as(usize, 0), forecast.len);
}