package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"

	"go.elara.ws/itd/infinitime"
	"go.elara.ws/logger/log"
)

// METResponse represents a response from
// the MET Norway API
type METResponse struct {
	Properties struct {
		Timeseries []struct {
			Time time.Time
			Data METData
		}
	}
}

// METData represents data in a METResponse
type METData struct {
	Instant struct {
		Details struct {
			AirPressure       float32 `json:"air_pressure_at_sea_level"`
			Temperature       float32 `json:"air_temperature"`
			DewPoint          float32 `json:"dew_point_temperature"`
			CloudAreaFraction float32 `json:"cloud_area_fraction"`
			FogAreaFraction   float32 `json:"fog_area_fraction"`
			RelativeHumidity  float32 `json:"relative_humidity"`
			UVIndex           float32 `json:"ultraviolet_index_clear_sky"`
			WindDirection     float32 `json:"wind_from_direction"`
			WindSpeed         float32 `json:"wind_speed"`
		}
	}
	NextHour struct {
		Summary struct {
			SymbolCode string `json:"symbol_code"`
		}
		Details struct {
			PrecipitationAmount float32 `json:"precipitation_amount"`
		}
	} `json:"next_1_hours"`
	Next6Hours struct {
		Details struct {
			MaxTemp float32 `json:"air_temperature_max"`
			MinTemp float32 `json:"air_temperature_min"`
		}
	} `json:"next_6_hours"`
}

// OSMData represents lat/long data from
// OpenStreetMap Nominatim
type OSMData []struct {
	Lat string `json:"lat"`
	Lon string `json:"lon"`
}

var sendWeatherCh = make(chan struct{}, 1)

func sleepCtx(ctx context.Context, d time.Duration) {
	select {
	case <-time.After(d):
	case <-ctx.Done():
	}
}

func initWeather(ctx context.Context, wg WaitGroup, dev *infinitime.Device) error {
	if !k.Bool("weather.enabled") {
		return nil
	}

	// Get location based on string in config
	lat, lon, err := getLocation(ctx, k.String("weather.location"))
	if err != nil {
		return err
	}

	timer := time.NewTimer(time.Hour)

	wg.Add(1)
	go func() {
		defer wg.Done("weather")
		for {
			select {
			case _, ok := <-ctx.Done():
				if !ok {
					return
				}
			default:
			}

			// Attempt to get weather
			data, err := getWeather(ctx, lat, lon)
			if err != nil {
				log.Warn("Error getting weather data").Err(err).Send()
				// Wait 15 minutes before retrying
				sleepCtx(ctx, 15*time.Minute)
				continue
			}

			// Get current data
			current := data.Properties.Timeseries[0]
			currentData := current.Data.Instant.Details

			icon := parseSymbol(current.Data.NextHour.Summary.SymbolCode)
			if icon == infinitime.WeatherIconClear {
				switch {
				case currentData.CloudAreaFraction > 50:
					icon = infinitime.WeatherIconHeavyClouds
				case currentData.CloudAreaFraction == 50:
					icon = infinitime.WeatherIconClouds
				case currentData.CloudAreaFraction > 0:
					icon = infinitime.WeatherIconFewClouds
				}
			}

			err = dev.SetCurrentWeather(infinitime.CurrentWeather{
				Time:        time.Now(),
				CurrentTemp: currentData.Temperature,
				MaxTemp:     current.Data.Next6Hours.Details.MaxTemp,
				MinTemp:     current.Data.Next6Hours.Details.MinTemp,
				Location:    k.String("weather.location"),
				Icon:        icon,
			})
			if err != nil {
				log.Error("Error setting weather").Err(err).Send()
			}

			// Reset timer to 1 hour
			timer.Stop()
			timer.Reset(time.Hour)

			// Wait for timer to fire or manual update signal
			select {
			case <-timer.C:
			case <-sendWeatherCh:
			case <-ctx.Done():
				return
			}
		}
	}()
	return nil
}

// getLocation returns the latitude and longitude
// given a location
func getLocation(ctx context.Context, loc string) (lat, lon float64, err error) {
	// Create request URL and perform GET request
	reqURL := fmt.Sprintf("https://nominatim.openstreetmap.org/search.php?q=%s&format=jsonv2", url.QueryEscape(loc))
	println(reqURL)
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqURL, nil)
	if err != nil {
		return
	}
	req.Header.Set("User-Agent", fmt.Sprintf("ITD/%s gitea.elara.ws/Elara6331/itd", strings.TrimSpace(version)))
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return
	}

	// Decode JSON from response into OSMData
	data := OSMData{}
	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return
	}
	// If no data points
	if len(data) == 0 {
		return
	}

	// Get first data point
	out := data[0]

	// Attempt to parse latitude
	lat, err = strconv.ParseFloat(out.Lat, 64)
	if err != nil {
		return
	}
	// Attempt to parse longitude
	lon, err = strconv.ParseFloat(out.Lon, 64)
	if err != nil {
		return
	}

	return
}

// getWeather gets weather data given a latitude and longitude
func getWeather(ctx context.Context, lat, lon float64) (*METResponse, error) {
	// Create new GET request
	req, err := http.NewRequestWithContext(
		ctx,
		http.MethodGet,
		fmt.Sprintf(
			"https://api.met.no/weatherapi/locationforecast/2.0/complete?lat=%.2f&lon=%.2f",
			lat,
			lon,
		),
		nil,
	)
	if err != nil {
		return nil, err
	}

	// Set identifying user agent as per NMI requirements
	req.Header.Set("User-Agent", fmt.Sprintf("ITD/%s gitea.elara.ws/Elara6331/itd", strings.TrimSpace(version)))

	// Perform request
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}

	// Decode JSON from response to METResponse struct
	out := &METResponse{}
	err = json.NewDecoder(res.Body).Decode(out)
	if err != nil {
		return nil, err
	}

	return out, nil
}

// parseSymbol determines what weather icon a symbol code codes for.
func parseSymbol(symCode string) infinitime.WeatherIcon {
	switch {
	case strings.Contains(symCode, "lightrain"):
		return infinitime.WeatherIconRain
	case strings.Contains(symCode, "rain"):
		return infinitime.WeatherIconCloudsWithRain
	case strings.Contains(symCode, "snow"),
		strings.Contains(symCode, "sleet"):
		return infinitime.WeatherIconSnow
	case strings.Contains(symCode, "thunder"):
		return infinitime.WeatherIconThunderstorm
	default:
		return infinitime.WeatherIconClear
	}
}