# Your wallet address to receive payments
PAY_TO=0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb

# Server configuration
PORT=3100

# Network (base-sepolia for testnet)
NETWORK=base-sepolia

interface WeatherData {
  city: string;
  temperature: number;
  conditions: string;
  humidity: number;
  timestamp: string;
}

// Geocoding: city name → lat/lon
async function getCityCoordinates(city: string): Promise<{ lat: number; lon: number }> {
  const url = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(city)}&count=1&language=en&format=json`;
  
  const response = await fetch(url);
  const data = await response.json();
  
  if (!data.results || data.results.length === 0) {
    throw new Error(`City not found: ${city}`);
  }
  
  return {
    lat: data.results[0].latitude,
    lon: data.results[0].longitude
  };
}

// Weather API: lat/lon → current weather
async function getWeatherByCoords(lat: number, lon: number): Promise<Omit<WeatherData, 'city'>> {
  const url = `https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&current_weather=true&hourly=relative_humidity_2m`;
  
  const response = await fetch(url);
  const data = await response.json();
  
  const current = data.current_weather;
  const humidity = data.hourly.relative_humidity_2m[0];
  
  // Map WMO weather codes to conditions
  const weatherCodes: Record<number, string> = {
    0: "Clear sky",
    1: "Mainly clear",
    2: "Partly cloudy",
    3: "Overcast",
    45: "Foggy",
    48: "Depositing rime fog",
    51: "Light drizzle",
    61: "Slight rain",
    63: "Moderate rain",
    65: "Heavy rain",
    71: "Slight snow",
    95: "Thunderstorm"
  };
  
  return {
    temperature: current.temperature,
    conditions: weatherCodes[current.weathercode] || "Unknown",
    humidity,
    timestamp: new Date().toISOString()
  };
}

// Main export: city name → weather data
export async function getWeather(city: string): Promise<WeatherData> {
  const coords = await getCityCoordinates(city);
  const weather = await getWeatherByCoords(coords.lat, coords.lon);
  
  return {
    city,
    ...weather
  };
}

import express, { Request, Response } from "express";
import { paymentMiddleware } from "x402-express";
import * as dotenv from "dotenv";
import { getWeather } from "./weather";

dotenv.config();

const app = express();
const port = process.env.PORT ? Number(process.env.PORT) : 3100;
const payTo = process.env.PAY_TO || "0x0000000000000000000000000000000000000000";
const network = process.env.NETWORK || "base-sepolia";

// Apply payment middleware BEFORE route handlers
app.use(paymentMiddleware(payTo, {
  "GET /weather": { price: "$0.001", network }
}));

// Protected route - only accessible after payment
app.get("/weather", async (req: Request, res: Response) => {
  try {
    const city = req.query.city as string;
    
    if (!city) {
      return res.status(400).json({
        error: "Missing 'city' query parameter",
        example: "/weather?city=San%20Francisco"
      });
    }
    
    // Fetch weather data
    const weatherData = await getWeather(city);
    
    // Return weather info
    res.json({
      success: true,
      data: weatherData
    });
  } catch (error) {
    res.status(500).json({
      error: "Failed to fetch weather",
      message: error instanceof Error ? error.message : String(error)
    });
  }
});

// Health check endpoint (free, no payment)
app.get("/health", (_req: Request, res: Response) => {
  res.json({
    status: "healthy",
    timestamp: new Date().toISOString(),
    payTo,
    network
  });
});

app.listen(port, () => {
  console.log(`✅ Weather paywall server running on http://localhost:${port}`);
  console.log(`💰 Payments to: ${payTo}`);
  console.log(`🌐 Network: ${network}`);
  console.log(`\nTry: curl -i "http://localhost:${port}/weather?city=Paris"`);
});