const { SharpApiAirportsService } = require('@sharpapi/sharpapi-node-airports');

const apiKey = process.env.SHARP_API_KEY;
const service = new SharpApiAirportsService(apiKey);

async function searchAirports() {
  try {
    // Search airports by city
    const airports = await service.getAirports({
      city: 'New York',
      per_page: 10,
      iata_assigned: true
    });

    console.log(`Found ${airports.data.length} airports:`);
    airports.data.forEach(airport => {
      console.log(`${airport.name} (${airport.iata}) - ${airport.city}, ${airport.country}`);
    });

    // Get specific airport by IATA code
    const jfk = await service.getAirportByIata('JFK');
    console.log('\nJFK Airport:', jfk);

    // Calculate flight duration
    const duration = await service.calculateFlightDuration('JFK', 'LAX');
    console.log('\nFlight JFK → LAX:', duration);
  } catch (error) {
    console.error('Error:', error.message);
  }
}

searchAirports();

const { SharpApiAirportsService } = require('@sharpapi/sharpapi-node-airports');

const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);

async function getUKAirports() {
  const airports = await service.getAirports({
    country: 'GB',
    iata_assigned: true,
    per_page: 50
  });

  console.log(`Found ${airports.meta.total} UK airports`);

  airports.data.forEach(airport => {
    console.log(`${airport.iata} - ${airport.name}, ${airport.city}`);
  });
}

getUKAirports();

const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);

async function searchFlights(departure, arrival) {
  // Get departure airport
  const depAirport = await service.getAirportByIata(departure);
  console.log(`Departure: ${depAirport.name}, ${depAirport.city}`);

  // Get arrival airport
  const arrAirport = await service.getAirportByIata(arrival);
  console.log(`Arrival: ${arrAirport.name}, ${arrAirport.city}`);

  // Calculate flight duration
  const duration = await service.calculateFlightDuration(departure, arrival);
  console.log(`Estimated Duration: ${duration.hours}h ${duration.minutes}m`);
  console.log(`Distance: ${duration.distance} km`);

  return {
    from: depAirport,
    to: arrAirport,
    duration: duration
  };
}

searchFlights('LHR', 'JFK').then(result => {
  console.log('Flight Details:', result);
});

const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);

async function buildDestinationSelector(countryCode) {
  // Get all cities with airports in the country
  const cities = await service.getCitiesByCountry(countryCode);

  const destinations = await Promise.all(
    cities.map(async (city) => {
      const airports = await service.getAirports({
        country: countryCode,
        city: city,
        iata_assigned: true,
        per_page: 10
      });

      return {
        city: city,
        airports: airports.data.map(a => ({
          code: a.iata,
          name: a.name,
          timezone: a.timezone
        }))
      };
    })
  );

  return destinations;
}

const usDestinations = await buildDestinationSelector('US');
console.log('US Destinations:', usDestinations);

const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);

async function findNearestAirport(latitude, longitude) {
  const nearby = await service.getNearbyAirports(latitude, longitude, 50, 5);

  console.log(`Airports within 50km of (${latitude}, ${longitude}):`);

  nearby.forEach((airport, index) => {
    console.log(`${index + 1}. ${airport.name} (${airport.iata})`);
    console.log(`   Distance: ${airport.distance} km`);
    console.log(`   City: ${airport.city}, ${airport.country}`);
  });

  return nearby[0]; // Return closest airport
}

// Find airports near San Francisco
findNearestAirport(37.7749, -122.4194);

const service = new SharpApiAirportsService(process.env.SHARP_API_KEY);

async function planMultiCityTrip(cities) {
  const itinerary = [];

  for (let i = 0; i < cities.length - 1; i++) {
    const fromCity = cities[i];
    const toCity = cities[i + 1];

    // Find airports in each city
    const fromAirports = await service.getAirports({
      city: fromCity,
      iata_assigned: true,
      per_page: 1
    });

    const toAirports = await service.getAirports({
      city: toCity,
      iata_assigned: true,
      per_page: 1
    });

    if (fromAirports.data.length === 0 || toAirports.data.length === 0) {
      console.log(`No airports found for ${fromCity} or ${toCity}`);
      continue;
    }

    const fromAirport = fromAirports.data[0];
    const toAirport = toAirports.data[0];

    // Calculate duration
    const duration = await service.calculateFlightDuration(
      fromAirport.iata,
      toAirport.iata
    );

    itinerary.push({
      leg: i + 1,
      from: {
        city: fromCity,
        airport: fromAirport.name,
        code: fromAirport.iata
      },
      to: {
        city: toCity,
        airport: toAirport.name,
        code: toAirport.iata
      },
      duration: duration
    });
  }

  return itinerary;
}

const cities = ['London', 'Paris', 'Rome', 'Barcelona'];
const trip = await planMultiCityTrip(cities);

console.log('Multi-City Itinerary:');
trip.forEach(leg => {
  console.log(`\nLeg ${leg.leg}: ${leg.from.city} → ${leg.to.city}`);
  console.log(`  ${leg.from.code} to ${leg.to.code}`);
  console.log(`  Duration: ${leg.duration.hours}h ${leg.duration.minutes}m`);
});