import random
import datetime

def generate_random_coordinates():
    latitude = random.uniform(-90, 90)
    longitude = random.uniform(-180, 180)
    return latitude, longitude

def determine_region(latitude, longitude):
    if latitude > 66.5:
        return "Arctic"
    if latitude < -66.5:
        return "Antarctica"
    
    if latitude > 0:
        # Northern Hemisphere
        if longitude > -30 and longitude < 60:
            return "Europe"
        if longitude >= 60 and longitude < 150:
            return "Asia"
        return "North America"
    else:
        # Southern Hemisphere
        if longitude > -30 and longitude < 60:
            return "Africa"
        if longitude >= 60 and longitude < 150:
            return "Oceania"
        return "South America"

def get_location_info(latitude, longitude):
    region = determine_region(latitude, longitude)
    
    # Simplified mapping of regions to countries and cities
    region_data = {
        "North America": {
            "countries": ["United States", "Canada", "Mexico"],
            "cities": ["New York", "Los Angeles", "Toronto", "Mexico City"],
            "terrains": ["Mountains", "Plains", "Forest", "Desert", "Coastal"]
        },
        "Europe": {
            "countries": ["United Kingdom", "France", "Germany", "Italy"],
            "cities": ["London", "Paris", "Berlin", "Rome"],
            "terrains": ["Mountains", "Plains", "Forest", "Coastal"]
        },
        # Add other regions as needed
    }
    
    data = region_data.get(region, {
        "countries": ["Unknown"],
        "cities": ["Unknown"],
        "terrains": ["Unknown"]
    })
    
    country = random.choice(data["countries"])
    city = random.choice(data["cities"])
    terrain = random.choice(data["terrains"])
    
    # Calculate local time based on longitude
    utc_now = datetime.datetime.utcnow()
    hour_offset = round(longitude / 15)
    local_time = utc_now + datetime.timedelta(hours=hour_offset)
    
    return {
        "region": region,
        "country": country,
        "city": city,
        "local_time": local_time.strftime("%H:%M"),
        "terrain": terrain
    }

# Usage example
lat, lon = generate_random_coordinates()
location_info = get_location_info(lat, lon)

print(f"Coordinates: {lat:.6f}, {lon:.6f}")
print(f"Country: {location_info['country']}")
print(f"Nearest City: {location_info['city']}")
print(f"Local Time: {location_info['local_time']}")
print(f"Terrain: {location_info['terrain']}")

function generateRandomCoordinates() {
  const latitude = Math.random() * 180 - 90;
  const longitude = Math.random() * 360 - 180;
  return { 
    latitude: parseFloat(latitude.toFixed(6)), 
    longitude: parseFloat(longitude.toFixed(6)) 
  };
}

function determineRegion(latitude, longitude) {
  if (latitude > 66.5) return 'Arctic';
  if (latitude < -66.5) return 'Antarctica';
  
  if (latitude > 0) {
    // Northern Hemisphere
    if (longitude > -30 && longitude < 60) return 'Europe';
    if (longitude >= 60 && longitude < 150) return 'Asia';
    return 'North America';
  } else {
    // Southern Hemisphere
    if (longitude > -30 && longitude < 60) return 'Africa';
    if (longitude >= 60 && longitude < 150) return 'Oceania';
    return 'South America';
  }
}

function getLocationInfo(latitude, longitude) {
  const region = determineRegion(latitude, longitude);
  
  // Simplified mapping of regions to countries and cities
  const regionData = {
    'North America': {
      countries: ['United States', 'Canada', 'Mexico'],
      cities: ['New York', 'Los Angeles', 'Toronto', 'Mexico City'],
      terrains: ['Mountains', 'Plains', 'Forest', 'Desert', 'Coastal']
    },
    'Europe': {
      countries: ['United Kingdom', 'France', 'Germany', 'Italy'],
      cities: ['London', 'Paris', 'Berlin', 'Rome'],
      terrains: ['Mountains', 'Plains', 'Forest', 'Coastal']
    },
    // Add other regions as needed
  };
  
  const data = regionData[region] || {
    countries: ['Unknown'],
    cities: ['Unknown'],
    terrains: ['Unknown']
  };
  
  const country = data.countries[Math.floor(Math.random() * data.countries.length)];
  const city = data.cities[Math.floor(Math.random() * data.cities.length)];
  const terrain = data.terrains[Math.floor(Math.random() * data.terrains.length)];
  
  // Calculate local time based on longitude
  const now = new Date();
  const hourOffset = Math.round(longitude / 15);
  const localDate = new Date(now.getTime());
  localDate.setUTCHours(now.getUTCHours() + hourOffset);
  
  return {
    region,
    country,
    city,
    localTime: localDate.getUTCHours().toString().padStart(2, '0') + ':' +
               localDate.getUTCMinutes().toString().padStart(2, '0'),
    terrain
  };
}

// Usage example
const coords = generateRandomCoordinates();
const locationInfo = getLocationInfo(coords.latitude, coords.longitude);

console.log(`Coordinates: ${coords.latitude}, ${coords.longitude}`);
console.log(`Country: ${locationInfo.country}`);
console.log(`Nearest City: ${locationInfo.city}`);
console.log(`Local Time: ${locationInfo.localTime}`);
console.log(`Terrain: ${locationInfo.terrain}`);

import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

public class EnhancedRandomLocationGenerator {
    private static final Random random = new Random();
    
    public static class Coordinates {
        public final double latitude;
        public final double longitude;
        
        public Coordinates(double latitude, double longitude) {
            this.latitude = latitude;
            this.longitude = longitude;
        }
        
        @Override
        public String toString() {
            return String.format("%.6f, %.6f", latitude, longitude);
        }
    }
    
    public static class LocationInfo {
        public final String region;
        public final String country;
        public final String city;
        public final String localTime;
        public final String terrain;
        
        public LocationInfo(String region, String country, String city, String localTime, String terrain) {
            this.region = region;
            this.country = country;
            this.city = city;
            this.localTime = localTime;
            this.terrain = terrain;
        }
    }
    
    public static Coordinates generateRandomCoordinates() {
        double latitude = random.nextDouble() * 180 - 90;
        double longitude = random.nextDouble() * 360 - 180;
        return new Coordinates(latitude, longitude);
    }
    
    public static String determineRegion(double latitude, double longitude) {
        if (latitude > 66.5) return "Arctic";
        if (latitude < -66.5) return "Antarctica";
        
        if (latitude > 0) {
            // Northern Hemisphere
            if (longitude > -30 && longitude < 60) return "Europe";
            if (longitude >= 60 && longitude < 150) return "Asia";
            return "North America";
        } else {
            // Southern Hemisphere
            if (longitude > -30 && longitude < 60) return "Africa";
            if (longitude >= 60 && longitude < 150) return "Oceania";
            return "South America";
        }
    }
    
    public static LocationInfo getLocationInfo(Coordinates coords) {
        String region = determineRegion(coords.latitude, coords.longitude);
        
        // Simplified mapping of regions to countries and cities
        Map<String, Map<String, List<String>>> regionData = new HashMap<>();
        
        Map<String, List<String>> northAmerica = new HashMap<>();
        northAmerica.put("countries", Arrays.asList("United States", "Canada", "Mexico"));
        northAmerica.put("cities", Arrays.asList("New York", "Los Angeles", "Toronto", "Mexico City"));
        northAmerica.put("terrains", Arrays.asList("Mountains", "Plains", "Forest", "Desert", "Coastal"));
        regionData.put("North America", northAmerica);
        
        Map<String, List<String>> europe = new HashMap<>();
        europe.put("countries", Arrays.asList("United Kingdom", "France", "Germany", "Italy"));
        europe.put("cities", Arrays.asList("London", "Paris", "Berlin", "Rome"));
        europe.put("terrains", Arrays.asList("Mountains", "Plains", "Forest", "Coastal"));
        regionData.put("Europe", europe);
        
        // Add other regions as needed
        
        Map<String, List<String>> data = regionData.get(region);
        if (data == null) {
            data = new HashMap<>();
            data.put("countries", Arrays.asList("Unknown"));
            data.put("cities", Arrays.asList("Unknown"));
            data.put("terrains", Arrays.asList("Unknown"));
        }
        
        String country = random.choice(data.get("countries"));
        String city = random.choice(data.get("cities"));
        String terrain = random.choice(data.get("terrains"));
        
        // Calculate local time based on longitude
        int hourOffset = (int) Math.round(coords.longitude / 15);
        ZonedDateTime utcNow = ZonedDateTime.now(ZoneOffset.UTC);
        ZonedDateTime localDateTime = utcNow.plusHours(hourOffset);
        String localTime = localDateTime.format(DateTimeFormatter.ofPattern("HH:mm"));
        
        return new LocationInfo(region, country, city, localTime, terrain);
    }
    
    public static void main(String[] args) {
        Coordinates coords = generateRandomCoordinates();
        LocationInfo info = getLocationInfo(coords);
        
        System.out.println("Coordinates: " + coords);
        System.out.println("Country: " + info.country);
        System.out.println("Nearest City: " + info.city);
        System.out.println("Local Time: " + info.localTime);
        System.out.println("Terrain: " + info.terrain);
    }
}

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <chrono>
#include <iomanip>

struct Coordinates {
    double latitude;
    double longitude;
};

struct LocationInfo {
    std::string region;
    std::string country;
    std::string city;
    std::string localTime;
    std::string terrain;
};

Coordinates generateRandomCoordinates() {
    double latitude = (static_cast<double>(rand()) / RAND_MAX) * 180 - 90;
    double longitude = (static_cast<double>(rand()) / RAND_MAX) * 360 - 180;
    return {latitude, longitude};
}

std::string determineRegion(double latitude, double longitude) {
    if (latitude > 66.5) return "Arctic";
    if (latitude < -66.5) return "Antarctica";
    
    if (latitude > 0) {
        // Northern Hemisphere
        if (longitude > -30 && longitude < 60) return "Europe";
        if (longitude >= 60 && longitude < 150) return "Asia";
        return "North America";
    } else {
        // Southern Hemisphere
        if (longitude > -30 && longitude < 60) return "Africa";
        if (longitude >= 60 && longitude < 150) return "Oceania";
        return "South America";
    }
}

std::string getRandomElement(const std::vector<std::string>& vec) {
    return vec[rand() % vec.size()];
}

LocationInfo getLocationInfo(const Coordinates& coords) {
    std::string region = determineRegion(coords.latitude, coords.longitude);
    
    // Simplified mapping of regions to countries and cities
    std::map<std::string, std::map<std::string, std::vector<std::string>>> regionData;
    
    regionData["North America"]["countries"] = {"United States", "Canada", "Mexico"};
    regionData["North America"]["cities"] = {"New York", "Los Angeles", "Toronto", "Mexico City"};
    regionData["North America"]["terrains"] = {"Mountains", "Plains", "Forest", "Desert", "Coastal"};
    
    regionData["Europe"]["countries"] = {"United Kingdom", "France", "Germany", "Italy"};
    regionData["Europe"]["cities"] = {"London", "Paris", "Berlin", "Rome"};
    regionData["Europe"]["terrains"] = {"Mountains", "Plains", "Forest", "Coastal"};
    
    // Add other regions as needed
    
    std::string country, city, terrain;
    if (regionData.find(region) != regionData.end()) {
        country = getRandomElement(regionData[region]["countries"]);
        city = getRandomElement(regionData[region]["cities"]);
        terrain = getRandomElement(regionData[region]["terrains"]);
    } else {
        country = "Unknown";
        city = "Unknown";
        terrain = "Unknown";
    }
    
    // Calculate local time based on longitude
    auto now = std::chrono::system_clock::now();
    auto now_time_t = std::chrono::system_clock::to_time_t(now);
    std::tm utc_tm;
    gmtime_r(&now_time_t, &utc_tm);
    
    int hourOffset = std::round(coords.longitude / 15);
    utc_tm.tm_hour += hourOffset;
    mktime(&utc_tm);
    
    char timeBuffer[6];
    std::strftime(timeBuffer, 6, "%H:%M", &utc_tm);
    std::string localTime(timeBuffer);
    
    return {region, country, city, localTime, terrain};
}

int main() {
    srand(time(0));
    
    Coordinates coords = generateRandomCoordinates();
    LocationInfo info = getLocationInfo(coords);
    
    std::cout << std::fixed << std::setprecision(6);
    std::cout << "Coordinates: " << coords.latitude << ", " << coords.longitude << std::endl;
    std::cout << "Country: " << info.country << std::endl;
    std::cout << "Nearest City: " << info.city << std::endl;
    std::cout << "Local Time: " << info.localTime << std::endl;
    std::cout << "Terrain: " << info.terrain << std::endl;
    
    return 0;
}

require 'date'

def generate_random_coordinates
  latitude = rand(-90.0..90.0)
  longitude = rand(-180.0..180.0)
  [latitude.round(6), longitude.round(6)]
end

def determine_region(latitude, longitude)
  if latitude > 66.5
    return "Arctic"
  elsif latitude < -66.5
    return "Antarctica"
  end
  
  if latitude > 0
    # Northern Hemisphere
    if longitude > -30 && longitude < 60
      return "Europe"
    elsif longitude >= 60 && longitude < 150
      return "Asia"
    else
      return "North America"
    end
  else
    # Southern Hemisphere
    if longitude > -30 && longitude < 60
      return "Africa"
    elsif longitude >= 60 && longitude < 150
      return "Oceania"
    else
      return "South America"
    end
  end
end

def get_location_info(latitude, longitude)
  region = determine_region(latitude, longitude)
  
  # Simplified mapping of regions to countries and cities
  region_data = {
    "North America" => {
      countries: ["United States", "Canada", "Mexico"],
      cities: ["New York", "Los Angeles", "Toronto", "Mexico City"],
      terrains: ["Mountains", "Plains", "Forest", "Desert", "Coastal"]
    },
    "Europe" => {
      countries: ["United Kingdom", "France", "Germany", "Italy"],
      cities: ["London", "Paris", "Berlin", "Rome"],
      terrains: ["Mountains", "Plains", "Forest", "Coastal"]
    }
    # Add other regions as needed
  }
  
  data = region_data[region] || {
    countries: ["Unknown"],
    cities: ["Unknown"],
    terrains: ["Unknown"]
  }
  
  country = data[:countries].sample
  city = data[:cities].sample
  terrain = data[:terrains].sample
  
  # Calculate local time based on longitude
  utc_now = DateTime.now.new_offset(0)
  hour_offset = (longitude / 15).round
  local_time = utc_now.new_offset(hour_offset / 24.0)
  
  {
    region: region,
    country: country,
    city: city,
    local_time: local_time.strftime("%H:%M"),
    terrain: terrain
  }
end

# Usage example
lat, lon = generate_random_coordinates
location_info = get_location_info(lat, lon)

puts "Coordinates: #{lat}, #{lon}"
puts "Country: #{location_info[:country]}"
puts "Nearest City: #{location_info[:city]}"
puts "Local Time: #{location_info[:local_time]}"
puts "Terrain: #{location_info[:terrain]}"

function copyToClipboard(text) {
  navigator.clipboard.writeText(text).then(() => {
    const copyButton = document.getElementById('copyButton');
    const originalText = copyButton.textContent;
    
    // सफलता संदेश दिखाएँ
    copyButton.textContent = 'कॉपी किया गया!';
    
    // 2 सेकंड बाद मूल पाठ पर वापस लौटें
    setTimeout(() => {
      copyButton.textContent = originalText;
    }, 2000);
  }, (err) => {
    console.error('पाठ कॉपी नहीं कर सका: ', err);
  });
}

// React Copy to Clipboard घटक के साथ उपयोग
import { CopyToClipboard } from 'react-copy-to-clipboard';

function CopyButton({ text }) {
  const [copied, setCopied] = useState(false);
  
  const handleCopy = () => {
    setCopied(true);
    setTimeout(() => setCopied(false), 2000);
  };
  
  return (
    <CopyToClipboard text={text} onCopy={handleCopy}>
      <button className="copy-button">
        {copied ? 'कॉपी किया गया!' : 'कॉपी करें'}
      </button>
    </CopyToClipboard>
  );
}