// Dubai Pulse API Client
class DubaiPulseAPI {
  constructor() {
    this.baseURL = 'https://www.dubaipulse.gov.ae/api';
  }

  async fetchDataset(datasetId, params = {}) {
    const url = new URL(`${this.baseURL}/dataset/${datasetId}`);
    Object.entries(params).forEach(([key, value]) => {
      url.searchParams.append(key, value);
    });

    const response = await fetch(url, {
      headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      throw new Error(`API Error: ${response.status}`);
    }

    return response.json();
  }
}

// Usage examples
const api = new DubaiPulseAPI();

// Get DED business licenses
const businesses = await api.fetchDataset('ded-business-licences', {
  area: 'Dubai Marina',
  sector: 'Technology',
  status: 'Active',
  limit: 100
});

// Get DLD property transactions
const properties = await api.fetchDataset('dld-real-estate-transactions', {
  property_type: 'Apartment',
  year: 2024,
  area: 'Downtown Dubai'
});

// Get RTA metro ridership
const ridership = await api.fetchDataset('rta-metro-ridership', {
  station: 'Burj Khalifa/Dubai Mall',
  month: '2024-01'
});

// DLD Property Data Fetcher
async function getPropertyData(area, propertyType = 'all') {
  const endpoint = 'https://www.dubaipulse.gov.ae/api/dataset/dld-real-estate-transactions';

  const params = new URLSearchParams({
    area: area,
    property_type: propertyType,
    year: new Date().getFullYear(),
    limit: 1000
  });

  try {
    const response = await fetch(`${endpoint}?${params}`);
    const data = await response.json();

    // Process and analyze the data
    const analysis = {
      totalTransactions: data.length,
      averagePrice: calculateAverage(data, 'price'),
      pricePerSqFt: calculateAverage(data, 'price_per_sqft'),
      topProjects: getTopProjects(data, 5),
      priceRange: {
        min: Math.min(...data.map(d => d.price)),
        max: Math.max(...data.map(d => d.price))
      },
      monthlyTrend: groupByMonth(data)
    };

    return { raw: data, analysis };
  } catch (error) {
    console.error('Error fetching property data:', error);
    return null;
  }
}

// Helper functions
function calculateAverage(data, field) {
  const sum = data.reduce((acc, item) => acc + (item[field] || 0), 0);
  return sum / data.length;
}

function getTopProjects(data, limit) {
  const projects = {};
  data.forEach(item => {
    projects[item.project] = (projects[item.project] || 0) + 1;
  });

  return Object.entries(projects)
    .sort((a, b) => b[1] - a[1])
    .slice(0, limit)
    .map(([name, count]) => ({ name, count }));
}

function groupByMonth(data) {
  const monthly = {};
  data.forEach(item => {
    const month = item.date.substring(0, 7); // YYYY-MM
    if (!monthly[month]) {
      monthly[month] = { count: 0, total: 0 };
    }
    monthly[month].count++;
    monthly[month].total += item.price;
  });

  return Object.entries(monthly).map(([month, stats]) => ({
    month,
    transactions: stats.count,
    avgPrice: stats.total / stats.count
  }));
}

// Usage
const dubaiMarinaData = await getPropertyData('Dubai Marina', 'Apartment');
console.log(`Average price: AED ${dubaiMarinaData.analysis.averagePrice.toLocaleString()}`);
console.log(`Price per sq ft: AED ${dubaiMarinaData.analysis.pricePerSqFt}`);

// Business Data API
class BusinessDataAPI {
  async searchBusinesses(filters) {
    const endpoint = 'https://www.dubaipulse.gov.ae/api/dataset/ded-business-licences';

    const response = await fetch(`${endpoint}?${new URLSearchParams(filters)}`);
    const data = await response.json();

    return this.processBusinessData(data);
  }

  processBusinessData(data) {
    // Group by sector
    const bySector = data.reduce((acc, business) => {
      const sector = business.sector || 'Unknown';
      if (!acc[sector]) acc[sector] = [];
      acc[sector].push(business);
      return acc;
    }, {});

    // Group by area
    const byArea = data.reduce((acc, business) => {
      const area = business.area || 'Unknown';
      if (!acc[area]) acc[area] = 0;
      acc[area]++;
      return acc;
    }, {});

    // Find top sub-sectors
    const subSectorCount = {};
    data.forEach(business => {
      const subSector = business.sub_sector || 'Unknown';
      subSectorCount[subSector] = (subSectorCount[subSector] || 0) + 1;
    });

    const topSubSectors = Object.entries(subSectorCount)
      .sort((a, b) => b[1] - a[1])
      .slice(0, 10)
      .map(([name, count]) => ({ name, count }));

    return {
      total: data.length,
      bySector,
      byArea,
      topSubSectors,
      raw: data
    };
  }

  async getCompetitors(sector, area) {
    return this.searchBusinesses({
      sector,
      area,
      status: 'Active',
      limit: 500
    });
  }

  async analyzeMark

etSaturation(sector, area) {
    const competitors = await this.getCompetitors(sector, area);

    // Estimate market size (simplified)
    const populationEstimate = 50000; // Per area estimate
    const businessesPerCapita = competitors.total / populationEstimate;

    return {
      competitorCount: competitors.total,
      saturationIndex: businessesPerCapita * 1000, // Per 1000 people
      topCompetitors: competitors.raw.slice(0, 10),
      subSectorBreakdown: competitors.topSubSectors,
      recommendation: this.getMarketRecommendation(businessesPerCapita)
    };
  }

  getMarketRecommendation(saturation) {
    if (saturation < 0.5) return 'Low competition - good opportunity';
    if (saturation < 1.5) return 'Moderate competition - differentiation needed';
    return 'High saturation - consider different area or niche';
  }
}

// Usage
const businessAPI = new BusinessDataAPI();

// Search for tech companies in DIFC
const techCompanies = await businessAPI.searchBusinesses({
  sector: 'Information and Communication',
  area: 'DIFC',
  status: 'Active'
});

// Analyze restaurant market in JBR
const marketAnalysis = await businessAPI.analyzeMarketSaturation(
  'Accommodation and Food Service',
  'JBR'
);

console.log(`Found ${techCompanies.total} tech companies`);
console.log(`Market saturation: ${marketAnalysis.saturationIndex.toFixed(2)} businesses per 1000 people`);
console.log(`Recommendation: ${marketAnalysis.recommendation}`);

// RTA Data Integration
class RTADataService {
  constructor() {
    this.baseURL = 'https://www.dubaipulse.gov.ae/api/dataset';
  }

  async getMetroRidership(station, period = 'monthly') {
    const endpoint = `${this.baseURL}/rta-metro-ridership`;
    const params = new URLSearchParams({
      station: station,
      period: period,
      year: new Date().getFullYear()
    });

    const response = await fetch(`${endpoint}?${params}`);
    const data = await response.json();

    return this.processRidershipData(data);
  }

  async getTrafficFlow(road, timeOfDay) {
    const endpoint = `${this.baseURL}/rta-traffic-flow`;
    const params = new URLSearchParams({
      road: road,
      time: timeOfDay
    });

    const response = await fetch(`${endpoint}?${params}`);
    return response.json();
  }

  async calculateCommuteTime(origin, destination, mode = 'car') {
    // Simplified commute calculation
    const trafficData = await this.getTrafficFlow(
      'Sheikh Zayed Road',
      new Date().getHours()
    );

    const baseTime = this.getBaseTime(origin, destination, mode);
    const congestionFactor = trafficData.congestion_level || 1;

    return {
      estimatedTime: baseTime * congestionFactor,
      mode: mode,
      alternativeRoutes: await this.getAlternativeRoutes(origin, destination),
      publicTransport: await this.getPublicTransportOptions(origin, destination)
    };
  }

  async getPublicTransportOptions(origin, destination) {
    // Get metro stations near origin and destination
    const options = [];

    // Check metro availability
    const metroRoute = this.findMetroRoute(origin, destination);
    if (metroRoute) {
      options.push({
        type: 'metro',
        duration: metroRoute.duration,
        cost: metroRoute.cost,
        stations: metroRoute.stations
      });
    }

    // Check bus routes
    const busRoutes = await this.findBusRoutes(origin, destination);
    options.push(...busRoutes);

    return options;
  }

  processRidershipData(data) {
    // Calculate statistics
    const totalRiders = data.reduce((sum, d) => sum + d.ridership, 0);
    const avgDaily = totalRiders / data.length;

    // Peak hours analysis
    const peakHours = data
      .filter(d => d.hour >= 7 && d.hour <= 9 || d.hour >= 17 && d.hour <= 19)
      .reduce((sum, d) => sum + d.ridership, 0);

    const offPeakHours = totalRiders - peakHours;

    return {
      total: totalRiders,
      dailyAverage: avgDaily,
      peakHoursPercentage: (peakHours / totalRiders * 100).toFixed(1),
      busiestDay: this.findBusiestDay(data),
      trend: this.calculateTrend(data)
    };
  }

  findBusiestDay(data) {
    const byDay = {};
    data.forEach(d => {
      byDay[d.day] = (byDay[d.day] || 0) + d.ridership;
    });

    return Object.entries(byDay)
      .sort((a, b) => b[1] - a[1])[0];
  }

  calculateTrend(data) {
    // Simple trend calculation
    const firstHalf = data.slice(0, data.length / 2);
    const secondHalf = data.slice(data.length / 2);

    const firstAvg = firstHalf.reduce((sum, d) => sum + d.ridership, 0) / firstHalf.length;
    const secondAvg = secondHalf.reduce((sum, d) => sum + d.ridership, 0) / secondHalf.length;

    const change = ((secondAvg - firstAvg) / firstAvg * 100).toFixed(1);
    return {
      direction: change > 0 ? 'increasing' : 'decreasing',
      percentage: Math.abs(change)
    };
  }
}

// Usage
const rta = new RTADataService();

// Get metro ridership for Burj Khalifa station
const ridership = await rta.getMetroRidership('Burj Khalifa/Dubai Mall');
console.log(`Daily average: ${ridership.dailyAverage.toLocaleString()} riders`);
console.log(`Peak hours: ${ridership.peakHoursPercentage}% of traffic`);

// Calculate commute options
const commute = await rta.calculateCommuteTime(
  'Dubai Marina',
  'DIFC',
  'car'
);
console.log(`Estimated time: ${commute.estimatedTime} minutes`);
console.log(`Public transport options: ${commute.publicTransport.length}`);

// Tourism Data API
class TourismDataAPI {
  async getVisitorStats(period = 'monthly') {
    const endpoint = 'https://www.dubaipulse.gov.ae/api/dataset/det-visitor-statistics';
    const year = new Date().getFullYear();

    const response = await fetch(`${endpoint}?year=${year}&period=${period}`);
    const data = await response.json();

    return this.analyzeTourismData(data);
  }

  async getHotelOccupancy(area) {
    const endpoint = 'https://www.dubaipulse.gov.ae/api/dataset/det-hotel-occupancy';

    const params = new URLSearchParams({
      area: area,
      year: new Date().getFullYear()
    });

    const response = await fetch(`${endpoint}?${params}`);
    return response.json();
  }

  analyzeTourismData(data) {
    // Group by nationality
    const byNationality = {};
    data.forEach(visitor => {
      const country = visitor.nationality;
      byNationality[country] = (byNationality[country] || 0) + visitor.count;
    });

    // Top source markets
    const topMarkets = Object.entries(byNationality)
      .sort((a, b) => b[1] - a[1])
      .slice(0, 10)
      .map(([country, visitors]) => ({
        country,
        visitors,
        percentage: (visitors / data.reduce((sum, d) => sum + d.count, 0) * 100).toFixed(1)
      }));

    // Monthly trend
    const monthlyTrend = data.reduce((acc, item) => {
      const month = item.month;
      if (!acc[month]) acc[month] = 0;
      acc[month] += item.count;
      return acc;
    }, {});

    // Year-over-year growth
    const currentYear = data.filter(d => d.year === new Date().getFullYear());
    const previousYear = data.filter(d => d.year === new Date().getFullYear() - 1);

    const growth = previousYear.length > 0
      ? ((currentYear.length - previousYear.length) / previousYear.length * 100).toFixed(1)
      : 0;

    return {
      totalVisitors: data.reduce((sum, d) => sum + d.count, 0),
      topMarkets,
      monthlyTrend,
      yearOverYearGrowth: growth,
      averageStayDuration: this.calculateAverageStay(data),
      seasonality: this.analyzeSeasonality(monthlyTrend)
    };
  }

  calculateAverageStay(data) {
    const totalNights = data.reduce((sum, d) => sum + (d.nights || 0), 0);
    const totalVisitors = data.reduce((sum, d) => sum + d.count, 0);
    return (totalNights / totalVisitors).toFixed(1);
  }

  analyzeSeasonality(monthlyData) {
    const months = Object.values(monthlyData);
    const average = months.reduce((sum, val) => sum + val, 0) / months.length;

    const peak = Math.max(...months);
    const low = Math.min(...months);

    return {
      peakMonth: Object.keys(monthlyData).find(key => monthlyData[key] === peak),
      lowMonth: Object.keys(monthlyData).find(key => monthlyData[key] === low),
      variation: ((peak - low) / average * 100).toFixed(1)
    };
  }

  async predictDemand(business, location) {
    const [visitors, occupancy] = await Promise.all([
      this.getVisitorStats(),
      this.getHotelOccupancy(location)
    ]);

    // Simple demand prediction based on visitor trends
    const demandScore = this.calculateDemandScore(visitors, occupancy, business);

    return {
      currentDemand: demandScore,
      trend: visitors.yearOverYearGrowth > 0 ? 'growing' : 'declining',
      seasonality: visitors.seasonality,
      recommendation: this.getDemandRecommendation(demandScore, visitors.seasonality)
    };
  }

  calculateDemandScore(visitors, occupancy, businessType) {
    // Simplified scoring
    let score = 50; // Base score

    // Adjust based on visitor growth
    score += visitors.yearOverYearGrowth * 0.5;

    // Adjust based on occupancy
    if (occupancy.rate) {
      score += (occupancy.rate - 70) * 0.3; // 70% is baseline
    }

    // Business type adjustments
    if (businessType.includes('tourism') || businessType.includes('hotel')) {
      score *= 1.2;
    }

    return Math.min(100, Math.max(0, score));
  }

  getDemandRecommendation(score, seasonality) {
    const recommendations = [];

    if (score > 75) {
      recommendations.push('High demand - consider premium pricing');
    } else if (score < 40) {
      recommendations.push('Low demand - focus on promotions');
    }

    if (seasonality.variation > 30) {
      recommendations.push(`Prepare for seasonal variations - peak in ${seasonality.peakMonth}`);
    }

    return recommendations;
  }
}

// Usage
const tourismAPI = new TourismDataAPI();

// Get visitor statistics
const visitors = await tourismAPI.getVisitorStats();
console.log(`Total visitors: ${visitors.totalVisitors.toLocaleString()}`);
console.log(`YoY Growth: ${visitors.yearOverYearGrowth}%`);
console.log('Top markets:', visitors.topMarkets.slice(0, 3));

// Predict demand for a hotel business
const demand = await tourismAPI.predictDemand('Luxury Hotel', 'JBR');
console.log(`Demand score: ${demand.currentDemand}/100`);
console.log('Recommendations:', demand.recommendation);