main.cpp

#include <spdlog/spdlog.h>

#include <CLI/CLI.hpp>
#include <iostream>
#include <memory>
#include <string>
#include <tl/expected.hpp>

#include "config.h"
#include "exceptions.h"
#include "weather_data.h"
#include "weather_service.h"

namespace weather {

/**
 * @brief Application configuration structure
 */
struct AppConfig {
  std::string city;
  bool debug_mode = false;
  bool fahrenheit = false;
  bool json_output = false;
  bool show_extended_info = false;
};

/**
 * @brief Setup logging based on debug mode
 */
void SetupLogging(bool debug_mode) {
  if (debug_mode) {
    spdlog::set_level(spdlog::level::debug);
    spdlog::set_pattern("[%Y-%m-%d %H:%M:%S] [%l] [%n] - %v");
  } else {
    spdlog::set_level(spdlog::level::info);
    spdlog::set_pattern("[%H:%M:%S] %v");
  }
}

/**
 * @brief Print weather data in human-readable format
 */
void PrintWeatherData(const WeatherData& weather_data, bool fahrenheit,
                      bool extended_info) {
  if (fahrenheit) {
    std::cout << "Weather in " << weather_data.GetCity() << ": "
              << weather_data.GetTemperatureFahrenheit() << "°F"
              << " (feels like " << weather_data.GetFeelsLikeFahrenheit()
              << "°F)"
              << ", " << weather_data.GetDescription() << std::endl;
  } else {
    std::cout << "Weather in " << weather_data.GetCity() << ": "
              << weather_data.GetTemperatureCelsius() << "°C"
              << " (feels like " << weather_data.GetFeelsLikeCelsius() << "°C)"
              << ", " << weather_data.GetDescription() << std::endl;
  }

  if (extended_info) {
    std::cout << "Humidity: " << weather_data.GetHumidity() << "%"
              << ", Pressure: " << weather_data.GetPressureHpa() << " hPa"
              << std::endl;
    std::cout << "Wind: " << weather_data.GetWindSpeedMs() << " m/s"
              << " at " << weather_data.GetWindDirectionDeg() << " degrees"
              << std::endl;
  }
}

/**
 * @brief Main application logic
 */
tl::expected<int, WeatherError> RunWeatherCli(const AppConfig& config) {
  try {
    // Create weather service with default OpenMeteoClient
    auto weather_service = std::make_unique<WeatherService>();

    // Get weather data
    auto weather_result = weather_service->GetWeather(config.city);
    if (!weather_result) {
      switch (weather_result.error()) {
        case WeatherError::Network:
          spdlog::error("Network connection failed");
          break;
        case WeatherError::ApiKey:
          spdlog::error("API error");
          break;
        case WeatherError::NotFound:
          spdlog::error("City '{}' not found. Please check the spelling.",
                        config.city);
          break;
        case WeatherError::Parse:
          spdlog::error("Failed to parse weather data");
          break;
        case WeatherError::Timeout:
          spdlog::error("Request timed out");
          break;
        default:
          spdlog::error("Failed to get weather data");
          break;
      }
      return tl::unexpected(weather_result.error());
    }

    const auto& weather_data = weather_result.value();

    // Output weather data
    if (config.json_output) {
      std::cout << weather_data.ToJson() << std::endl;
    } else {
      PrintWeatherData(weather_data, config.fahrenheit,
                       config.show_extended_info);
    }

    return 0;

  } catch (const ConfigException& e) {
    spdlog::error("Configuration error: {}", e.what());
    return tl::unexpected(WeatherError::InvalidInput);
  } catch (const WeatherApiException& e) {
    spdlog::error("Weather API error: {}", e.what());
    return tl::unexpected(WeatherError::Network);
  } catch (const WeatherException& e) {
    spdlog::error("Weather error: {}", e.what());
    return tl::unexpected(WeatherError::Network);
  } catch (const std::exception& e) {
    spdlog::error("Unexpected error: {}", e.what());
    return tl::unexpected(WeatherError::Network);
  }
}

}  // namespace weather

/**
 * @brief Main entry point
 */
int main(int argc, char* argv[]) {
  weather::AppConfig config;

  // Setup CLI11 command line parser
  CLI::App app{"Weather CLI - Get current weather information for any city"};
  app.set_version_flag("--version", "1.0.0");

  // Add arguments
  auto* city_option = app.add_option("city", config.city,
                                     "Name of the city to get weather for");
  city_option->required();

  // Add flags
  app.add_flag("-d,--debug", config.debug_mode, "Enable debug logging");
  app.add_flag("-f,--fahrenheit", config.fahrenheit,
               "Show temperature in Fahrenheit");
  app.add_flag("-j,--json", config.json_output, "Output in JSON format");
  app.add_flag("-e,--extended", config.show_extended_info,
               "Show extended weather information");

  // Parse command line
  try {
    app.parse(argc, argv);
  } catch (const CLI::ParseError& e) {
    return app.exit(e);
  }

  // Setup logging
  weather::SetupLogging(config.debug_mode);

  spdlog::debug("Starting Weather CLI application");
  spdlog::debug("City: {}, Debug: {}, Fahrenheit: {}, JSON: {}", config.city,
                config.debug_mode, config.fahrenheit, config.json_output);

  // Run the weather CLI application
  auto result = weather::RunWeatherCli(config);

  if (!result) {
    std::cerr << "Error occurred during execution" << std::endl;
    return 1;
  }

  return result.value();
}