using System;

using System.Collections.Generic;

using System.Data;

using System.Linq;

using System.Threading.Tasks;

​

namespace NearestCity

{

    public class WorldCityTable

    {

        public double Lat { get; set; }

        public double Lng { get; set; }

        public string City { get; set; } // Added city name for representation

    }

​

    public interface IDatabase

    {

        Task<List<WorldCityTable>> QueryAsync<WorldCityTable>(string sql, params object[] parameters);

    }

​

    public class NearestCityFinder

    {

        private readonly IDatabase _database;

​

        public NearestCityFinder(IDatabase database)

        {

            _database = database ?? throw new ArgumentNullException(nameof(database));

        }

​

        /// <summary>

        /// Asynchronously finds the nearest city to the given latitude and longitude using a spatial index.

        /// </summary>

        /// <param name="currentLat">The latitude of the current location.</param>

        /// <param name="currentLng">The longitude of the current location.</param>

        /// <returns>The nearest city as a WorldCityTable object, or null if no city is found.  Throws ArgumentException if the latitude or longitude is invalid.</returns>

        public async Task<WorldCityTable> GetNearestCityAsync(double currentLat, double currentLng)

        {

            // Validate input parameters

            if (currentLat < -90 || currentLat > 90)

            {

                throw new ArgumentException("Latitude must be between -90 and 90 degrees.", nameof(currentLat));

            }

​

            if (currentLng < -180 || currentLng > 180)

            {

                throw new ArgumentException("Longitude must be between -180 and 180 degrees.", nameof(currentLng));

            }

​

            // SQL query using spatial index (assuming PostGIS)

            string sqlQuery = @"

                SELECT City, Lat, Lng

                FROM worldcities

                ORDER BY ST_Distance(ST_MakePoint(Lng, Lat), ST_MakePoint(@lng, @lat))

                LIMIT 1;";

​

            try

            {

                var cities = await _database.QueryAsync<WorldCityTable>(sqlQuery, new { lat = currentLat, lng = currentLng });

​

                return cities.FirstOrDefault();

            }

            catch (Exception ex)

            {

                // Log the exception for debugging purposes

                Console.WriteLine($"Error executing database query: {ex.Message}");

                // Re-throw the exception to be handled upstream. You might want to use a custom exception type.

                throw;

            }

        }

    }

​

    public class Program

    {

        public static async Task Main(string[] args)

        {

            // Mock database implementation for demonstration

            var mockDatabase = new MockDatabase();

            mockDatabase.AddCity(new WorldCityTable { City = "New York", Lat = 40.7128, Lng = -74.0060 });

            mockDatabase.AddCity(new WorldCityTable { City = "Los Angeles", Lat = 34.0522, Lng = -118.2437 });

            mockDatabase.AddCity(new WorldCityTable { City = "London", Lat = 51.5074, Lng = 0.1278 });

            mockDatabase.AddCity(new WorldCityTable { City = "Sydney", Lat = -33.8688, Lng = 151.2093 });

​

​

            var nearestCityFinder = new NearestCityFinder(mockDatabase);

​

            try

            {

                double latitude = 34.0;

                double longitude = -118.0;

                var nearestCity = await nearestCityFinder.GetNearestCityAsync(latitude, longitude);

​

                if (nearestCity != null)

                {

                    Console.WriteLine($"The nearest city to ({latitude}, {longitude}) is {nearestCity.City} (Lat: {nearestCity.Lat}, Lng: {nearestCity.Lng})");

                }

                else

                {

                    Console.WriteLine("No cities found in the database.");

                }

            }

            catch (ArgumentException ex)

            {

                Console.WriteLine($"Error: {ex.Message}");

            }

            catch (Exception ex)

            {

                Console.WriteLine($"An unexpected error occurred: {ex.Message}");

            }

        }

    }

​

    // Mock database implementation for testing purposes

    public class MockDatabase : IDatabase

    {

        private readonly List<WorldCityTable> _cities = new List<WorldCityTable>();

​

        public void AddCity(WorldCityTable city)

        {

            _cities.Add(city);

        }

​

        public async Task<List<WorldCityTable>> QueryAsync<WorldCityTable>(string sql, params object[] parameters)

        {

            // This is a simplified mock implementation.  A real implementation would execute the SQL query against a database.

            // This mock implementation only works for the spatial query.

​

            if (sql.Contains("ST_Distance"))

            {

                var lat = (double)((dynamic)parameters[0]).lat;

                var lng = (double)((dynamic)parameters[0]).lng;

​

                return _cities.OrderBy(city => Math.Pow(city.Lat - lat, 2) + Math.Pow(city.Lng - lng, 2)).Take(1).Cast<WorldCityTable>().ToList();

            }

​

            return await Task.FromResult(_cities.Cast<WorldCityTable>().ToList()); // Return all cities if not a spatial query

        }

    }

}