server.js

// Load local .env values in development without affecting production (no-op if file missing)
if (process.env.NODE_ENV !== 'production') {
  try {
    require('dotenv').config();
  } catch (err) {
    // dotenv is optional; ignore if not installed in production build
    console.warn('dotenv not loaded (optional):', err.message);
  }
}

const express = require('express');
const http = require('http');
const { Server } = require('socket.io');
const cors = require('cors');
const { v4: uuidv4 } = require('uuid');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');
const https = require('https');
const { connectToDatabase, getCollection } = require('./db');
const multer = require('multer');
const OpenAI = require('openai');

const app = express();

// Determine which front-end origins are allowed to talk to the API / socket server.
// Supports wildcards such as https://*.vercel.app and literal "*" to allow all.
const defaultOrigins = [
  'http://localhost:5173',
  'https://agentflowcorp.vercel.app'
];
const rawOrigins = process.env.ALLOWED_ORIGINS || defaultOrigins.join(',');
const originEntries = rawOrigins.split(',').map(origin => origin.trim()).filter(Boolean);
const allowAllOrigins = originEntries.includes('*');

const exactOrigins = originEntries.filter(origin => origin && !origin.includes('*') && origin !== '*');
const wildcardOrigins = originEntries
  .filter(origin => origin.includes('*'))
  .map(origin => {
    const escaped = origin.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
    const regexSource = `^${escaped.replace(/\\\*/g, '.*')}$`;
    return {
      pattern: origin,
      regex: new RegExp(regexSource)
    };
  });

function isOriginAllowed(origin) {
  if (allowAllOrigins || !origin) {
    return true;
  }

  if (exactOrigins.includes(origin)) {
    return true;
  }

  return wildcardOrigins.some(({ regex }) => regex.test(origin));
}

const corsOriginSetting = allowAllOrigins
  ? true
  : (origin, callback) => {
      if (isOriginAllowed(origin)) {
        return callback(null, true);
      }
      console.warn('CORS blocked origin:', origin);
      return callback(new Error('Not allowed by CORS'));
    };

const corsOptions = {
  origin: corsOriginSetting,
  methods: ['GET', 'POST', 'PATCH', 'DELETE']
};

const corsSummary = allowAllOrigins
  ? '*'
  : [
      ...exactOrigins,
      ...wildcardOrigins.map(({ pattern }) => `${pattern} (wildcard)`)
    ].join(', ');

const server = http.createServer(app);
const io = new Server(server, { cors: corsOptions });

// Middleware
app.use(cors(corsOptions));
app.use(express.json());

// ============================================
// AUTHENTICATION CONFIG
// ============================================

const JWT_SECRET = process.env.JWT_SECRET || 'agentflow-mvp-secret-change-in-production';
const GOOGLE_MAPS_API_KEY = process.env.GOOGLE_MAPS_API_KEY || process.env.VITE_GOOGLE_MAPS_API_KEY || '';
const OPENAI_API_KEY = process.env.OPENAI_API_KEY || process.env.VITE_OPENAI_API_KEY || '';

// Initialize OpenAI client
const openai = OPENAI_API_KEY ? new OpenAI({ apiKey: OPENAI_API_KEY }) : null;

// Configure multer for file uploads (memory storage for images)
const upload = multer({
  storage: multer.memoryStorage(),
  limits: {
    fileSize: 10 * 1024 * 1024, // 10MB max file size
  },
  fileFilter: (req, file, cb) => {
    // Accept images only
    if (file.mimetype.startsWith('image/')) {
      cb(null, true);
    } else {
      cb(new Error('Only image files are allowed'));
    }
  }
});

// ============================================
// IN-MEMORY DATA STORE (Replace with DB later)
// ============================================

const users = new Map(); // NEW: User accounts (email/password)
const agents = new Map();
const clients = new Map(); // NEW: Persistent client profiles
const showingSessions = new Map(); // NEW: One session per client per day
const dailyRoutes = new Map();
const locationShares = new Map();
const agentLocations = new Map();

async function hydrateFromDatabase() {
  const usersCol = getCollection('users');
  const agentsCol = getCollection('agents');
  const clientsCol = getCollection('clients');
  const sessionsCol = getCollection('sessions');

  if (!usersCol || !agentsCol || !clientsCol || !sessionsCol) {
    return;
  }

  const [userDocs, agentDocs, clientDocs, sessionDocs] = await Promise.all([
    usersCol.find({}).toArray(),
    agentsCol.find({}).toArray(),
    clientsCol.find({}).toArray(),
    sessionsCol.find({}).toArray()
  ]);

  userDocs.forEach(doc => users.set(doc.id, doc));
  agentDocs.forEach(doc => agents.set(doc.id, doc));
  clientDocs.forEach(doc => clients.set(doc.id, doc));
  sessionDocs.forEach(doc => showingSessions.set(doc.id, doc));

  console.log('✅ Hydrated data from MongoDB', {
    users: userDocs.length,
    agents: agentDocs.length,
    clients: clientDocs.length,
    sessions: sessionDocs.length
  });
}

async function saveUser(user) {
  const col = getCollection('users');
  if (!col) {
    console.warn('⚠️  Database not connected - user save skipped:', user.id);
    return;
  }
  try {
    const result = await col.updateOne({ id: user.id }, { $set: user }, { upsert: true });
    console.log(`✅ Saved user ${user.email} to database`);
    return result;
  } catch (error) {
    console.error('❌ Failed to save user to database:', error.message);
    throw new Error(`Database save failed for user ${user.id}: ${error.message}`);
  }
}

async function saveAgent(agent) {
  const col = getCollection('agents');
  if (!col) {
    console.warn('⚠️  Database not connected - agent save skipped:', agent.id);
    return;
  }
  try {
    const result = await col.updateOne({ id: agent.id }, { $set: agent }, { upsert: true });
    console.log(`✅ Saved agent ${agent.email} to database`);
    return result;
  } catch (error) {
    console.error('❌ Failed to save agent to database:', error.message);
    throw new Error(`Database save failed for agent ${agent.id}: ${error.message}`);
  }
}

async function saveClient(client) {
  const col = getCollection('clients');
  if (!col) {
    console.warn('⚠️  Database not connected - client save skipped:', client.id);
    return;
  }
  try {
    const result = await col.updateOne({ id: client.id }, { $set: client }, { upsert: true });
    console.log(`✅ Saved client ${client.name} to database`);
    return result;
  } catch (error) {
    console.error('❌ Failed to save client to database:', error.message);
    throw new Error(`Database save failed for client ${client.id}: ${error.message}`);
  }
}

async function removeClient(clientId) {
  const col = getCollection('clients');
  if (!col) {
    console.warn('⚠️  Database not connected - client removal skipped:', clientId);
    return;
  }
  try {
    const result = await col.deleteOne({ id: clientId });
    console.log(`✅ Removed client ${clientId} from database`);
    return result;
  } catch (error) {
    console.error('❌ Failed to remove client from database:', error.message);
    throw new Error(`Database delete failed for client ${clientId}: ${error.message}`);
  }
}

async function saveSession(session) {
  const col = getCollection('sessions');
  if (!col) {
    console.warn('⚠️  Database not connected - session save skipped:', session.id);
    return;
  }
  try {
    const result = await col.updateOne({ id: session.id }, { $set: session }, { upsert: true });
    console.log(`✅ Saved session ${session.id} to database`);
    return result;
  } catch (error) {
    console.error('❌ Failed to save session to database:', error.message);
    throw new Error(`Database save failed for session ${session.id}: ${error.message}`);
  }
}

async function removeSession(sessionId) {
  const col = getCollection('sessions');
  if (!col) {
    console.warn('⚠️  Database not connected - session removal skipped:', sessionId);
    return;
  }
  try {
    const result = await col.deleteOne({ id: sessionId });
    console.log(`✅ Removed session ${sessionId} from database`);
    return result;
  } catch (error) {
    console.error('❌ Failed to remove session from database:', error.message);
    throw new Error(`Database delete failed for session ${sessionId}: ${error.message}`);
  }
}

// Seed a demo agent for testing
const demoAgentId = uuidv4();
agents.set(demoAgentId, {
  id: demoAgentId,
  email: 'demo@agentflow.app',
  name: 'Agent John',
  phone: '+1-416-555-1234',
  home_address: '100 Queen St, Toronto',
  home_lat: 43.6532,
  home_lng: -79.3832,
  created_at: new Date().toISOString()
});

console.log('Demo Agent ID:', demoAgentId);

// Seed some demo clients
const demoClients = [
  {
    id: uuidv4(),
    agent_id: demoAgentId,
    name: 'Sarah Chen',
    phone: '+1-416-555-0101',
    email: 'sarah@example.com',
    home_address: '456 Bloor St West, Toronto',
    home_lat: 43.6677,
    home_lng: -79.4055,
    created_at: new Date().toISOString()
  },
  {
    id: uuidv4(),
    agent_id: demoAgentId,
    name: 'James Rodriguez',
    phone: '+1-416-555-0202',
    email: 'james@example.com',
    home_address: '789 College St, Toronto',
    home_lat: 43.6571,
    home_lng: -79.4113,
    created_at: new Date().toISOString()
  },
  {
    id: uuidv4(),
    agent_id: demoAgentId,
    name: 'Emily Wong',
    phone: '+1-416-555-0303',
    email: 'emily@example.com',
    home_address: '321 Spadina Ave, Toronto',
    home_lat: 43.6550,
    home_lng: -79.3998,
    created_at: new Date().toISOString()
  }
];

demoClients.forEach(client => clients.set(client.id, client));

console.log(`Seeded ${demoClients.length} demo clients`);

const seededDemoAgents = new Set();
const seedingInProgress = new Set(); // Track in-progress seeding to prevent race conditions

async function seedDemoDataForAgent(agentId) {
  if (!agentId || agentId === demoAgentId || seededDemoAgents.has(agentId)) {
    return;
  }

  // Check if seeding is already in progress for this agent (race condition prevention)
  if (seedingInProgress.has(agentId)) {
    console.log(`⏳ Demo seeding already in progress for agent ${agentId}, skipping duplicate request`);
    return;
  }

  const agent = agents.get(agentId);
  if (!agent || agent.is_demo !== true) {
    return;
  }

  const alreadyHasClients = Array.from(clients.values()).some(c => c.agent_id === agentId);
  if (alreadyHasClients) {
    seededDemoAgents.add(agentId);
    return;
  }

  // Mark seeding as in progress
  seedingInProgress.add(agentId);

  try {
    // Double-check after acquiring lock (in case another request just finished)
    if (seededDemoAgents.has(agentId)) {
      return;
    }

    demoClients.forEach(template => {
      const clone = {
        ...template,
        id: uuidv4(),
        agent_id: agentId,
        created_at: new Date().toISOString()
      };
      clients.set(clone.id, clone);
    });

    seededDemoAgents.add(agentId);
    console.log(`✅ Seeded ${demoClients.length} demo clients for agent ${agentId}`);

    // Optionally save to database (non-blocking)
    const clonedClients = Array.from(clients.values()).filter(c => c.agent_id === agentId);
    Promise.all(clonedClients.map(c => saveClient(c))).catch(err => {
      console.warn('⚠️  Failed to persist demo clients to database:', err.message);
    });
  } finally {
    // Always remove from in-progress set
    seedingInProgress.delete(agentId);
  }
}

// ============================================
// AUTHENTICATION MIDDLEWARE
// ============================================

// Verify JWT token and attach user to request
function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

  if (!token) {
    return res.status(401).json({ error: 'Access token required' });
  }

  jwt.verify(token, JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({ error: 'Invalid or expired token' });
    }
    req.user = user; // { userId, email }
    next();
  });
}

// ============================================
// HELPER FUNCTIONS
// ============================================

// Timeout wrapper for promises
function withTimeout(promise, timeoutMs, errorMessage = 'Operation timed out') {
  return Promise.race([
    promise,
    new Promise((_, reject) =>
      setTimeout(() => reject(new Error(errorMessage)), timeoutMs)
    )
  ]);
}

// Input validation helpers
function isValidEmail(email) {
  if (!email || typeof email !== 'string') {
    return false;
  }
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email.trim());
}

function isValidPhone(phone) {
  if (!phone || typeof phone !== 'string') {
    return false;
  }
  // Basic phone validation - at least 10 digits
  const digitsOnly = phone.replace(/\D/g, '');
  return digitsOnly.length >= 10 && digitsOnly.length <= 15;
}

function sanitizeString(str, maxLength = 255) {
  if (!str || typeof str !== 'string') {
    return '';
  }
  return str.trim().slice(0, maxLength);
}

// Mock geocoding (replace with Google Maps API later)
function mockGeocode(address) {
  // Simple mock - returns random Toronto coordinates
  // WARNING: This is a fallback and should only be used in development/demo mode
  const baseLatToronto = 43.65;
  const baseLngToronto = -79.38;

  console.warn(`⚠️  GEOCODING FALLBACK: Using mock coordinates for address "${address}". Configure GOOGLE_MAPS_API_KEY for accurate geocoding.`);

  return {
    lat: baseLatToronto + (Math.random() * 0.1 - 0.05),
    lng: baseLngToronto + (Math.random() * 0.1 - 0.05),
    isMock: true
  };
}

// Validate coordinates are within reasonable bounds
function validateCoordinates(lat, lng) {
  if (typeof lat !== 'number' || typeof lng !== 'number') {
    return false;
  }

  // Basic validation: coordinates must be valid numbers
  if (!Number.isFinite(lat) || !Number.isFinite(lng)) {
    return false;
  }

  // Validate lat/lng ranges
  if (lat < -90 || lat > 90 || lng < -180 || lng > 180) {
    console.error(`❌ Invalid coordinates: lat=${lat}, lng=${lng} (out of range)`);
    return false;
  }

  // Optional: Validate for Toronto/North America area (can be removed for global use)
  // Toronto area: roughly lat 40-50, lng -85 to -70
  if (lat < 35 || lat > 55 || lng < -100 || lng > -60) {
    console.warn(`⚠️  Coordinates outside expected region (North America): lat=${lat}, lng=${lng}`);
    // Don't return false - just warn, as this might be intentional
  }

  return true;
}

function fetchJson(url) {
  return new Promise((resolve, reject) => {
    https
      .get(url, res => {
        let data = '';
        res.on('data', chunk => { data += chunk; });
        res.on('end', () => {
          try {
            resolve(JSON.parse(data));
          } catch (err) {
            reject(err);
          }
        });
      })
      .on('error', reject);
  });
}

async function geocodeAddress(address) {
  if (!GOOGLE_MAPS_API_KEY || !address) {
    return null;
  }

  try {
    const url = `https://maps.googleapis.com/maps/api/geocode/json?address=${encodeURIComponent(address)}&key=${GOOGLE_MAPS_API_KEY}`;
    const response = await fetchJson(url);

    // Validate response structure
    if (!response || typeof response !== 'object') {
      console.error('❌ Invalid response from Google Geocoding API');
      return null;
    }

    if (response.status === 'OK' && response.results && response.results.length > 0) {
      const location = response.results[0]?.geometry?.location;
      if (location && validateCoordinates(location.lat, location.lng)) {
        return { lat: location.lat, lng: location.lng };
      }
      console.error('❌ Invalid coordinates returned from geocoding API');
      return null;
    }

    if (response.status === 'ZERO_RESULTS') {
      console.warn(`⚠️  Geocoding returned zero results for: "${address}"`);
    } else if (response.status !== 'OK') {
      console.warn(`⚠️  Geocoding failed with status: ${response.status}`, response.error_message);
    }
  } catch (error) {
    console.error('❌ Error calling Google Geocoding API:', error.message);
  }

  return null;
}

async function resolveCoordinates(lat, lng, address) {
  const parsedLat = typeof lat === 'number' ? lat : parseFloat(lat);
  const parsedLng = typeof lng === 'number' ? lng : parseFloat(lng);

  // Use provided coordinates if valid
  if (Number.isFinite(parsedLat) && Number.isFinite(parsedLng) && validateCoordinates(parsedLat, parsedLng)) {
    console.log(`✅ Using provided coordinates: (${parsedLat}, ${parsedLng})`);
    return { lat: parsedLat, lng: parsedLng };
  }

  // Try geocoding the address
  const geocoded = await geocodeAddress(address);
  if (geocoded) {
    console.log(`✅ Geocoded address "${address}" to coordinates: (${geocoded.lat}, ${geocoded.lng})`);
    return geocoded;
  }

  // Fallback to mock coordinates (with warning)
  const mock = mockGeocode(address);
  return { lat: mock.lat, lng: mock.lng };
}

async function optimizePropertiesWithGoogle(session, client, agent, includePickup) {
  if (!GOOGLE_MAPS_API_KEY || !session.properties || session.properties.length <= 1) {
    return { properties: session.properties, legs: null };
  }

  try {
    const origin = agent?.home_address;
    let destination = includePickup
      ? (client?.home_address || agent?.home_address)
      : (session.properties[session.properties.length - 1]?.address || agent?.home_address);

    const waypointAddresses = session.properties.map(prop => prop.address).filter(Boolean);
    if (!origin || !destination || waypointAddresses.length === 0) {
      console.warn('⚠️  Missing required addresses for route optimization');
      return { properties: session.properties, legs: null };
    }

    const params = new URLSearchParams({
      origin,
      destination,
      mode: 'driving',
      departure_time: 'now',
      traffic_model: 'best_guess',
      key: GOOGLE_MAPS_API_KEY
    });
    params.append('waypoints', `optimize:true|${waypointAddresses.join('|')}`);

    const url = `https://maps.googleapis.com/maps/api/directions/json?${params.toString()}`;
    const response = await fetchJson(url);

    // Validate response structure
    if (!response || typeof response !== 'object') {
      console.error('❌ Invalid response from Google Directions API');
      return { properties: session.properties, legs: null };
    }

    if (response.status === 'OK') {
      if (!response.routes || response.routes.length === 0) {
        console.warn('⚠️  Directions API returned OK but no routes');
        return { properties: session.properties, legs: null };
      }

      const route = response.routes[0];
      if (!route) {
        console.error('❌ First route is undefined');
        return { properties: session.properties, legs: null };
      }

      const order = route.waypoint_order || [];

      // Validate waypoint order
      if (order.length !== session.properties.length) {
        console.warn(`⚠️  Waypoint order length mismatch: expected ${session.properties.length}, got ${order.length}`);
        return { properties: session.properties, legs: null };
      }

      const optimized = order.map(index => {
        if (index < 0 || index >= session.properties.length) {
          console.error(`❌ Invalid waypoint index: ${index}`);
          return null;
        }
        return session.properties[index];
      }).filter(Boolean);

      if (optimized.length !== session.properties.length) {
        console.warn('⚠️  Some properties were lost during optimization, using original order');
        return { properties: session.properties, legs: null };
      }

      return { properties: optimized, legs: route.legs || null };
    }

    // Handle specific error statuses
    if (response.status === 'ZERO_RESULTS') {
      console.warn('⚠️  Directions API found no route between the locations');
    } else if (response.status === 'OVER_QUERY_LIMIT') {
      console.error('❌ Google API quota exceeded');
    } else if (response.status === 'REQUEST_DENIED') {
      console.error('❌ Google API request denied:', response.error_message);
    } else {
      console.warn(`⚠️  Directions API returned status: ${response.status}`, response.error_message);
    }
  } catch (error) {
    console.error('❌ Directions API error:', error.message);
  }

  return { properties: session.properties, legs: null };
}

function ensureAgent(agentId) {
  const fallbackAgent = agents.get(demoAgentId);
  if (!agentId) {
    return fallbackAgent;
  }

  if (agents.has(agentId)) {
    const existing = agents.get(agentId);
    if (existing?.is_demo) {
      seedDemoDataForAgent(agentId);
    }
    return existing;
  }

  const placeholder = {
    id: agentId,
    email: `demo-${agentId}@agentflow.app`,
    name: 'Demo Agent',
    phone: '',
    home_address: fallbackAgent?.home_address || '100 Queen St, Toronto',
    home_lat: fallbackAgent?.home_lat || 43.6532,
    home_lng: fallbackAgent?.home_lng || -79.3832,
    created_at: new Date().toISOString(),
    is_demo: true
  };

  agents.set(agentId, placeholder);
  seedDemoDataForAgent(agentId);
  return placeholder;
}

// Calculate straight-line distance (km) between two points
function calculateDistance(lat1, lng1, lat2, lng2) {
  const R = 6371; // Earth's radius in km
  const dLat = (lat2 - lat1) * Math.PI / 180;
  const dLng = (lng2 - lng1) * Math.PI / 180;
  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
    Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
    Math.sin(dLng / 2) * Math.sin(dLng / 2);
  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
  return R * c;
}

// Calculate estimated drive time (minutes) based on distance
function estimateDriveTime(distanceKm) {
  // Average Toronto traffic: ~30 km/h in city
  return Math.ceil((distanceKm / 30) * 60);
}

// Calculate time window for a client session
async function calculateSessionTimeWindow(session, client, agent) {
  const SHOWING_DURATION_MIN = 30; // Fixed: 30 min per property

  const pickupLat = client.home_lat;
  const pickupLng = client.home_lng;

  const includePickup = !!session.pickup_client;

  // Optimize property sequence using Google Directions when available
  const googleOptimization = await optimizePropertiesWithGoogle(session, client, agent, includePickup);
  const optimizedProperties = googleOptimization.properties || session.properties;
  const googleLegs = googleOptimization.legs;
  let legIndex = 0;

  function getDriveStats(fallbackMinutes, fallbackDistanceKm) {
    if (googleLegs && googleLegs[legIndex]) {
      const leg = googleLegs[legIndex++];
      const minutes = Math.ceil((leg.duration_in_traffic?.value || leg.duration?.value || (fallbackMinutes * 60)) / 60);
      const distanceKm = leg.distance?.value ? parseFloat((leg.distance.value / 1000).toFixed(2)) : fallbackDistanceKm;
      return { minutes, distanceKm };
    }
    return { minutes: fallbackMinutes, distanceKm: fallbackDistanceKm };
  }

  // Calculate timeline
  const timeline = [];
  let currentTime = new Date(session.start_time);
  let currentLat = agent.home_lat;
  let currentLng = agent.home_lng;

  timeline.push({
    type: 'departure',
    location: 'Agent Home',
    address: agent.home_address,
    time: currentTime.toISOString(),
    lat: currentLat,
    lng: currentLng
  });

  if (includePickup && pickupLat && pickupLng) {
    const distToPickup = calculateDistance(currentLat, currentLng, pickupLat, pickupLng);
    const driveToPickup = estimateDriveTime(distToPickup);
    currentTime = new Date(currentTime.getTime() + driveToPickup * 60000);
    currentLat = pickupLat;
    currentLng = pickupLng;

    timeline.push({
      type: 'pickup',
      location: 'Client Pickup',
      address: client.home_address,
      client_name: client.name,
      time: currentTime.toISOString(),
      lat: currentLat,
      lng: currentLng
    });
  }

  // 2. Visit each property
  optimizedProperties.forEach((prop, index) => {
    const distToProp = calculateDistance(currentLat, currentLng, prop.lat, prop.lng);
    const fallbackDrive = estimateDriveTime(distToProp);
    const { minutes: driveToProp, distanceKm } = getDriveStats(fallbackDrive, parseFloat(distToProp.toFixed(2)));

    // Drive to property
    currentTime = new Date(currentTime.getTime() + driveToProp * 60000);

    timeline.push({
      type: 'property',
      location: `Property ${index + 1}`,
      address: prop.address,
      arrival_time: currentTime.toISOString(),
      duration_min: SHOWING_DURATION_MIN,
      lat: prop.lat,
      lng: prop.lng,
      drive_time_min: driveToProp,
      distance_km: distanceKm
    });

    // Showing duration
    currentTime = new Date(currentTime.getTime() + SHOWING_DURATION_MIN * 60000);
    currentLat = prop.lat;
    currentLng = prop.lng;
  });

  // 3. Wrap up / dropoff logic
  // IMPORTANT: Client pickup/dropoff uses client.home_address as the DEFAULT ADDRESS
  // This is the client's home location used for both pickup and dropoff calculations
  if (includePickup) {
    const lastPropLat = currentLat;
    const lastPropLng = currentLng;
    const distHomeFromLast = calculateDistance(lastPropLat, lastPropLng, client.home_lat, client.home_lng);
    const fallbackDriveHome = estimateDriveTime(distHomeFromLast);
    const { minutes: driveHomeFromLast } = getDriveStats(fallbackDriveHome, parseFloat(distHomeFromLast.toFixed(2)));

    let dropoffLat, dropoffLng, dropoffAddress, dropoffType;

    // Dropoff decision logic:
    // - If return drive to client home < 30 min: drop client at their home (client.home_address)
    // - Otherwise: drop client at last property (saves time/cost)
    if (driveHomeFromLast < 30) {
      dropoffLat = client.home_lat;
      dropoffLng = client.home_lng;
      dropoffAddress = client.home_address; // DEFAULT ADDRESS for dropoff
      dropoffType = 'dropoff_home';
      currentTime = new Date(currentTime.getTime() + driveHomeFromLast * 60000);
    } else {
      dropoffLat = lastPropLat;
      dropoffLng = lastPropLng;
      dropoffAddress = optimizedProperties[optimizedProperties.length - 1]?.address;
      dropoffType = 'dropoff_property';
    }

    timeline.push({
      type: dropoffType,
      location: 'Client Dropoff',
      address: dropoffAddress,
      client_name: client.name,
      time: currentTime.toISOString(),
      lat: dropoffLat,
      lng: dropoffLng
    });
  } else if (optimizedProperties.length > 0) {
    timeline.push({
      type: 'wrap_up',
      location: 'Last Stop',
      address: optimizedProperties[optimizedProperties.length - 1].address,
      time: currentTime.toISOString(),
      lat: currentLat,
      lng: currentLng
    });
  }

  const sessionEndTime = currentTime.toISOString();
  const totalDurationMin = Math.ceil((new Date(sessionEndTime) - new Date(session.start_time)) / 60000);

  return {
    session_id: session.id,
    client_id: session.client_id,
    client_name: client.name,
    start_time: session.start_time,
    end_time: sessionEndTime,
    total_duration_min: totalDurationMin,
    optimized_properties: optimizedProperties,
    timeline
  };
}

// Detect conflicts between sessions
function detectConflicts(sessionsForDay) {
  const conflicts = [];

  for (let i = 0; i < sessionsForDay.length - 1; i++) {
    for (let j = i + 1; j < sessionsForDay.length; j++) {
      const session1Start = new Date(sessionsForDay[i].start_time);
      const session1End = new Date(sessionsForDay[i].end_time);
      const session2Start = new Date(sessionsForDay[j].start_time);
      const session2End = new Date(sessionsForDay[j].end_time);

      // Check for overlap
      if (session1Start < session2End && session2Start < session1End) {
        const overlapMin = Math.min(
          (session1End - session2Start) / 60000,
          (session2End - session1Start) / 60000
        );

        conflicts.push({
          type: 'overlap',
          session1_id: sessionsForDay[i].session_id,
          session1_client: sessionsForDay[i].client_name,
          session2_id: sessionsForDay[j].session_id,
          session2_client: sessionsForDay[j].client_name,
          overlap_minutes: Math.ceil(overlapMin),
          message: `Conflict: ${sessionsForDay[i].client_name} (ends ${session1End.toLocaleTimeString()}) overlaps with ${sessionsForDay[j].client_name} (starts ${session2Start.toLocaleTimeString()})`
        });
      }
    }
  }

  return conflicts;
}

// ============================================
// API ENDPOINTS
// ============================================

// Health check
app.get('/api/health', (req, res) => {
  res.json({
    status: 'ok',
    app: 'AgentFlow MVP',
    timestamp: new Date().toISOString(),
    demoAgentId
  });
});

// ============================================
// AUTHENTICATION ENDPOINTS
// ============================================

// Register new user
app.post('/api/auth/register', async (req, res) => {
  try {
    const { email, password, name, phone } = req.body;

    // Validation
    if (!email || !password || !name) {
      return res.status(400).json({ error: 'Email, password, and name are required' });
    }

    // Validate email format
    if (!isValidEmail(email)) {
      return res.status(400).json({ error: 'Invalid email format' });
    }

    // Validate password strength
    if (password.length < 8) {
      return res.status(400).json({ error: 'Password must be at least 8 characters long' });
    }

    // Validate name length
    if (sanitizeString(name).length < 2) {
      return res.status(400).json({ error: 'Name must be at least 2 characters long' });
    }

    // Validate phone if provided
    if (phone && !isValidPhone(phone)) {
      return res.status(400).json({ error: 'Invalid phone number format' });
    }

    // Check if email already exists
    const existingUser = Array.from(users.values()).find(u => u.email === email);
    if (existingUser) {
      return res.status(409).json({ error: 'Email already registered' });
    }

    // Hash password
    const passwordHash = await bcrypt.hash(password, 10);

    // Create user (sanitize inputs)
    const userId = uuidv4();
    const user = {
      id: userId,
      email: email.trim().toLowerCase(),
      passwordHash,
      name: sanitizeString(name),
      phone: phone ? sanitizeString(phone, 20) : '',
      created_at: new Date().toISOString()
    };
    users.set(userId, user);
    await saveUser(user);

    // Create agent profile for this user
    const agentId = uuidv4();
    const agent = {
      id: agentId,
      user_id: userId,
      email: email.trim().toLowerCase(),
      name: sanitizeString(name),
      phone: phone ? sanitizeString(phone, 20) : '',
      home_address: '',
      home_lat: null,
      home_lng: null,
      created_at: new Date().toISOString(),
      is_demo: false
    };
    agents.set(agentId, agent);
    await saveAgent(agent);

    // Generate JWT token
    const token = jwt.sign(
      { userId, email, agentId },
      JWT_SECRET,
      { expiresIn: '30d' }
    );

    res.status(201).json({
      message: 'User registered successfully',
      token,
      user: {
        id: userId,
        email,
        name,
        phone: phone || '',
        agentId
      }
    });
  } catch (error) {
    console.error('Register error:', error);
    res.status(500).json({ error: 'Failed to register user' });
  }
});

// Login user
app.post('/api/auth/login', async (req, res) => {
  try {
    const { email, password } = req.body;

    // Validation
    if (!email || !password) {
      return res.status(400).json({ error: 'Email and password are required' });
    }

    // Find user by email
    const user = Array.from(users.values()).find(u => u.email === email);
    if (!user) {
      return res.status(401).json({ error: 'Invalid email or password' });
    }

    // Verify password
    const passwordMatch = await bcrypt.compare(password, user.passwordHash);
    if (!passwordMatch) {
      return res.status(401).json({ error: 'Invalid email or password' });
    }

    // Find agent profile
    const agent = Array.from(agents.values()).find(a => a.user_id === user.id);

    // Generate JWT token
    const token = jwt.sign(
      { userId: user.id, email: user.email, agentId: agent?.id },
      JWT_SECRET,
      { expiresIn: '30d' }
    );

    res.json({
      message: 'Login successful',
      token,
      user: {
        id: user.id,
        email: user.email,
        name: user.name,
        phone: user.phone,
        agentId: agent?.id
      }
    });
  } catch (error) {
    console.error('Login error:', error);
    res.status(500).json({ error: 'Failed to login' });
  }
});

// Get current user info (protected route example)
app.get('/api/auth/me', authenticateToken, (req, res) => {
  try {
    const user = users.get(req.user.userId);
    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }

    const agent = Array.from(agents.values()).find(a => a.user_id === user.id);

    res.json({
      id: user.id,
      email: user.email,
      name: user.name,
      phone: user.phone,
      agentId: agent?.id,
      created_at: user.created_at
    });
  } catch (error) {
    console.error('Get user error:', error);
    res.status(500).json({ error: 'Failed to get user info' });
  }
});

// ============================================
// CLIENT MANAGEMENT
// ============================================

// Get all clients for an agent
app.get('/api/clients', (req, res) => {
  try {
    const { agent_id = demoAgentId } = req.query;

    const agent = ensureAgent(agent_id);
    if (agent?.is_demo) {
      seedDemoDataForAgent(agent_id);
    }

    const agentClients = Array.from(clients.values())
      .filter(c => c.agent_id === agent_id)
      .sort((a, b) => a.name.localeCompare(b.name));

    res.json({
      data: agentClients,
      count: agentClients.length
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Create a new client
app.post('/api/clients', async (req, res) => {
  try {
    const {
      agent_id = demoAgentId,
      name,
      phone,
      email,
      home_address,
      home_lat,
      home_lng
    } = req.body;

    if (!name || !home_address) {
      return res.status(400).json({
        error: 'Missing required fields: name, home_address'
      });
    }

    // Validate inputs
    if (sanitizeString(name).length < 2) {
      return res.status(400).json({ error: 'Client name must be at least 2 characters long' });
    }

    if (sanitizeString(home_address).length < 5) {
      return res.status(400).json({ error: 'Home address must be at least 5 characters long' });
    }

    if (email && !isValidEmail(email)) {
      return res.status(400).json({ error: 'Invalid email format' });
    }

    if (phone && !isValidPhone(phone)) {
      return res.status(400).json({ error: 'Invalid phone number format' });
    }

    ensureAgent(agent_id);

    // Use provided coordinates when available, otherwise geocode / mock them
    const { lat, lng } = await resolveCoordinates(home_lat, home_lng, home_address);

    const client = {
      id: uuidv4(),
      agent_id,
      name: sanitizeString(name),
      phone: phone ? sanitizeString(phone, 20) : null,
      email: email ? email.trim().toLowerCase() : null,
      home_address: sanitizeString(home_address, 500),
      home_lat: lat,
      home_lng: lng,
      created_at: new Date().toISOString()
    };

    clients.set(client.id, client);
    await saveClient(client);

    console.log('Created client:', client);

    res.status(201).json(client);
  } catch (error) {
    console.error('Error creating client:', error);
    res.status(500).json({ error: error.message });
  }
});

// Delete a client
app.delete('/api/clients/:id', async (req, res) => {
  const client = clients.get(req.params.id);

  if (!client) {
    return res.status(404).json({ error: 'Client not found' });
  }

  // Also delete all sessions for this client
  const clientSessions = Array.from(showingSessions.values())
    .filter(s => s.client_id === req.params.id);

  clientSessions.forEach(s => showingSessions.delete(s.id));
  await Promise.all(clientSessions.map(s => removeSession(s.id)));

  clients.delete(req.params.id);
  await removeClient(client.id);

  console.log('Deleted client:', client.id);

  res.status(204).send();
});

// ============================================
// AGENT PROFILE MANAGEMENT
// ============================================

app.get('/api/agent/profile', (req, res) => {
  const { agent_id } = req.query;

  if (!agent_id) {
    return res.status(400).json({ error: 'agent_id is required' });
  }

  const agent = agents.get(agent_id);

  if (!agent) {
    return res.status(404).json({ error: 'Agent not found' });
  }

  res.json({
    id: agent.id,
    name: agent.name,
    phone: agent.phone || '',
    home_address: agent.home_address || '',
    home_lat: agent.home_lat,
    home_lng: agent.home_lng
  });
});

app.patch('/api/agent/profile', async (req, res) => {
  try {
    const { agent_id, name, phone, home_address, home_lat, home_lng } = req.body;

    if (!agent_id) {
      return res.status(400).json({ error: 'agent_id is required' });
    }

    const agent = agents.get(agent_id);

    if (!agent) {
      return res.status(404).json({ error: 'Agent not found' });
    }

    if (name) agent.name = name;
    if (typeof phone !== 'undefined') agent.phone = phone;

    if (home_address) {
      agent.home_address = home_address;
      const coords = await resolveCoordinates(home_lat, home_lng, home_address);
      agent.home_lat = coords.lat;
      agent.home_lng = coords.lng;
    }

    agents.set(agent_id, agent);
    await saveAgent(agent);

    res.json({
      id: agent.id,
      name: agent.name,
      phone: agent.phone || '',
      home_address: agent.home_address || '',
      home_lat: agent.home_lat,
      home_lng: agent.home_lng
    });
  } catch (error) {
    console.error('Error updating agent profile:', error);
    res.status(500).json({ error: 'Failed to update agent profile' });
  }
});

// ============================================
// SHOWING SESSION MANAGEMENT
// ============================================

function extractDateString(value) {
  if (!value) return null;
  if (typeof value === 'string') {
    return value.split('T')[0];
  }
  try {
    return new Date(value).toISOString().split('T')[0];
  } catch (err) {
    return null;
  }
}

function sessionExistsForClient(agentId, clientId, date) {
  const targetDate = extractDateString(date);
  if (!targetDate) {
    return false;
  }
  return Array.from(showingSessions.values()).some(session => {
    if (session.agent_id !== agentId || session.client_id !== clientId) {
      return false;
    }
    const sessionDate = extractDateString(session.date || session.start_time);
    return sessionDate === targetDate;
  });
}

function normalizeAddressValue(address = '') {
  return address.trim().toLowerCase();
}

function normalizeUnitValue(unit = '') {
  return unit.replace(/^unit\s+/i, '').trim();
}

function formatUnitLabel(unit) {
  const cleaned = normalizeUnitValue(unit);
  return cleaned ? `Unit ${cleaned}` : '';
}

function mergePropertiesForStorage(properties = []) {
  if (!Array.isArray(properties)) return [];

  const merged = [];

  for (let i = 0; i < properties.length; i++) {
    const current = { ...properties[i] };
    const duplicates = [current];

    while (
      i + 1 < properties.length &&
      normalizeAddressValue(properties[i + 1].address) === normalizeAddressValue(current.address)
    ) {
      duplicates.push(properties[i + 1]);
      i++;
    }

    if (duplicates.length > 1) {
      const uniqueUnits = Array.from(
        new Set(
          duplicates
            .map(item => normalizeUnitValue(item.unit))
            .filter(Boolean)
        )
      );
      const timeDetails = duplicates
        .map(item => {
          if (!item.time) return null;
          const unitLabel = formatUnitLabel(item.unit);
          return unitLabel ? `${item.time} (${unitLabel})` : item.time;
        })
        .filter(Boolean);

      const noteSegments = [];
      if (uniqueUnits.length > 0) {
        noteSegments.push(`Units: ${uniqueUnits.join(', ')}`);
      }
      noteSegments.push(`${duplicates.length} showings at this address`);
      if (timeDetails.length > 0) {
        noteSegments.push(`Times: ${timeDetails.join(', ')}`);
      }
      if (current.notes) {
        noteSegments.push(current.notes);
      }

      current.notes = noteSegments.join(' • ');
    }

    merged.push(current);
  }

  return merged;
}

// Get all sessions for a date
app.get('/api/sessions', (req, res) => {
  try {
    const { agent_id = demoAgentId, date } = req.query;

    let sessions = Array.from(showingSessions.values())
      .filter(s => s.agent_id === agent_id);

    if (date) {
      const targetDate = extractDateString(date);
      sessions = sessions.filter(s => {
        const sessionDate = extractDateString(s.date);
        return sessionDate === targetDate;
      });
    }

    // Enhance with client info
    const enhancedSessions = sessions.map(session => {
      const client = clients.get(session.client_id);
      return {
        ...session,
        client_name: client?.name || 'Unknown',
        client_phone: client?.phone,
        client_email: client?.email,
        client_home_address: client?.home_address
      };
    });

    res.json({
      data: enhancedSessions,
      count: enhancedSessions.length
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Create a new showing session
app.post('/api/sessions', async (req, res) => {
  try {
    const {
      agent_id = demoAgentId,
      client_id,
      date,
      start_time,
      properties, // Array of { address: string, lat?: number, lng?: number }
      pickup_client = false
    } = req.body;

    if (!client_id || !date || !start_time || !properties || properties.length === 0) {
      return res.status(400).json({
        error: 'Missing required fields: client_id, date, start_time, properties'
      });
    }

    const client = clients.get(client_id);
    if (!client) {
      return res.status(404).json({ error: 'Client not found' });
    }

    ensureAgent(agent_id);

    // Attach coordinates for each property (falling back to mock coords if missing)
    const geocodedProperties = [];
    for (const prop of properties) {
      const coords = await resolveCoordinates(prop.lat, prop.lng, prop.address);
      geocodedProperties.push({
        address: prop.address,
        lat: coords.lat,
        lng: coords.lng
      });
    }

    const session = {
      id: uuidv4(),
      agent_id,
      client_id,
      date,
      start_time: new Date(`${date}T${start_time}`).toISOString(),
      properties: geocodedProperties,
      status: 'pending',
      pickup_client: !!pickup_client,
      created_at: new Date().toISOString()
    };

    showingSessions.set(session.id, session);
    await saveSession(session);

    console.log('Created showing session:', session);

    res.status(201).json(session);
  } catch (error) {
    console.error('Error creating session:', error);
    res.status(500).json({ error: error.message });
  }
});

app.patch('/api/sessions/:id', async (req, res) => {
  try {
    const session = showingSessions.get(req.params.id);

    if (!session) {
      return res.status(404).json({ error: 'Session not found' });
    }

    if (req.body.start_time) {
      const sessionDate = session.date || (session.start_time ? new Date(session.start_time).toISOString().split('T')[0] : new Date().toISOString().split('T')[0]);
      const iso = new Date(`${sessionDate}T${req.body.start_time}`);
      if (!Number.isNaN(iso.getTime())) {
        session.start_time = iso.toISOString();
      }
    }

    if (typeof req.body.pickup_client !== 'undefined') {
      session.pickup_client = !!req.body.pickup_client;
    }

    if (Array.isArray(req.body.properties)) {
      const updatedProps = [];
      for (const prop of req.body.properties) {
        const coords = await resolveCoordinates(prop.lat, prop.lng, prop.address);
        updatedProps.push({ address: prop.address, lat: coords.lat, lng: coords.lng });
      }
      session.properties = updatedProps;
    }

    showingSessions.set(session.id, session);
    await saveSession(session);

    res.json(session);
  } catch (error) {
    console.error('Error updating session:', error);
    res.status(500).json({ error: error.message });
  }
});

// Add a property to an existing session
app.post('/api/sessions/:id/properties', async (req, res) => {
  try {
    const session = showingSessions.get(req.params.id);

    if (!session) {
      return res.status(404).json({ error: 'Session not found' });
    }

    const { address, lat, lng } = req.body;

    if (!address) {
      return res.status(400).json({ error: 'Missing required field: address' });
    }

    // Geocode the new property (or use provided coordinates)
    const coords = await resolveCoordinates(lat, lng, address);

    session.properties.push({
      address,
      lat: coords.lat,
      lng: coords.lng
    });

    session.updated_at = new Date().toISOString();

    showingSessions.set(session.id, session);
    await saveSession(session);

    console.log('Added property to session:', session.id);

    res.json(session);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Delete a session
app.delete('/api/sessions/:id', async (req, res) => {
  const session = showingSessions.get(req.params.id);

  if (!session) {
    return res.status(404).json({ error: 'Session not found' });
  }

  showingSessions.delete(req.params.id);
  await removeSession(session.id);

  console.log('Deleted session:', session.id);

  res.status(204).send();
});

// ============================================
// DEMO DATA MANAGEMENT
// ============================================

app.delete('/api/demo/:agent_id', (req, res) => {
  const { agent_id } = req.params;

  if (!agent_id) {
    return res.status(400).json({ error: 'agent_id is required' });
  }

  if (agent_id === demoAgentId) {
    return res.status(400).json({ error: 'Cannot reset the global demo dataset' });
  }

  let deletedClients = 0;
  let deletedSessions = 0;
  let deletedRoutes = 0;

  for (const [id, client] of clients.entries()) {
    if (client.agent_id === agent_id) {
      clients.delete(id);
      deletedClients++;
    }
  }

  for (const [id, session] of showingSessions.entries()) {
    if (session.agent_id === agent_id) {
      showingSessions.delete(id);
      deletedSessions++;
    }
  }

  for (const [key, route] of dailyRoutes.entries()) {
    if (route.agent_id === agent_id) {
      dailyRoutes.delete(key);
      deletedRoutes++;
    }
  }

  locationShares.delete(agent_id);
  agentLocations.delete(agent_id);

  const agentRecord = agents.get(agent_id);
  if (agentRecord?.is_demo) {
    agents.delete(agent_id);
  }

  seededDemoAgents.delete(agent_id);

  console.log(`Cleared demo data for agent ${agent_id}`);

  res.json({
    message: 'Demo data cleared',
    stats: {
      clients: deletedClients,
      sessions: deletedSessions,
      routes: deletedRoutes
    }
  });
});

// ============================================
// GOOGLE PLACES PROXY
// ============================================

function ensureGoogleApiConfigured(res) {
  if (!GOOGLE_MAPS_API_KEY) {
    res.status(500).json({ error: 'Google Maps API key is not configured on the server' });
    return false;
  }
  return true;
}

app.get('/api/places/autocomplete', async (req, res) => {
  try {
    if (!ensureGoogleApiConfigured(res)) return;

    const { query, sessiontoken } = req.query;
    if (!query) {
      return res.status(400).json({ error: 'Missing required parameter: query' });
    }

    const params = new URLSearchParams({
      input: query,
      types: 'address',
      components: 'country:us|country:ca',
      key: GOOGLE_MAPS_API_KEY,
      sessiontoken: sessiontoken || uuidv4()
    });

    const url = `https://maps.googleapis.com/maps/api/place/autocomplete/json?${params.toString()}`;
    const response = await fetchJson(url);

    if (response.status !== 'OK') {
      return res.status(400).json({
        error: response.error_message || response.status,
        predictions: []
      });
    }

    const predictions = response.predictions.map(prediction => ({
      description: prediction.description,
      structured_formatting: prediction.structured_formatting,
      secondary: prediction.structured_formatting?.secondary_text || '',
      place_id: prediction.place_id
    }));

    res.json({ predictions });
  } catch (error) {
    console.error('Places autocomplete error:', error);
    res.status(500).json({ error: 'Failed to fetch autocomplete suggestions' });
  }
});

app.get('/api/places/details', async (req, res) => {
  try {
    if (!ensureGoogleApiConfigured(res)) return;

    const { place_id, sessiontoken } = req.query;
    if (!place_id) {
      return res.status(400).json({ error: 'Missing required parameter: place_id' });
    }

    const params = new URLSearchParams({
      place_id,
      fields: 'formatted_address,geometry/location',
      key: GOOGLE_MAPS_API_KEY,
      sessiontoken: sessiontoken || uuidv4()
    });

    const url = `https://maps.googleapis.com/maps/api/place/details/json?${params.toString()}`;
    const response = await fetchJson(url);

    if (response.status !== 'OK') {
      return res.status(400).json({ error: response.error_message || response.status });
    }

    const result = response.result;
    res.json({
      address: result.formatted_address,
      lat: result.geometry?.location?.lat,
      lng: result.geometry?.location?.lng
    });
  } catch (error) {
    console.error('Places details error:', error);
    res.status(500).json({ error: 'Failed to fetch place details' });
  }
});

// ============================================
// ROUTE OPTIMIZATION
// ============================================

// Optimize daily route for all sessions
app.post('/api/routes/optimize', async (req, res) => {
  try {
    const { agent_id = demoAgentId, date } = req.body;

    if (!date) {
      return res.status(400).json({ error: 'Missing required field: date' });
    }

    const agent = ensureAgent(agent_id);

    // Get all sessions for this date
    const targetDate = new Date(date).toISOString().split('T')[0];
    const sessionsForDay = Array.from(showingSessions.values())
      .filter(s => {
        const sessionDate = new Date(s.date).toISOString().split('T')[0];
        return s.agent_id === agent_id && sessionDate === targetDate;
      })
      .sort((a, b) => new Date(a.start_time) - new Date(b.start_time));

    if (sessionsForDay.length === 0) {
      return res.json({
        date,
        sessions: [],
        conflicts: [],
        message: 'No sessions scheduled for this date'
      });
    }

    // Calculate time windows for each session (async because of Google Directions)
    // Add 30 second timeout to prevent hanging if Google API is slow
    const optimizationPromise = Promise.all(
      sessionsForDay.map(async session => {
        const client = clients.get(session.client_id);
        return calculateSessionTimeWindow(session, client, agent);
      })
    );

    const optimizedSessions = await withTimeout(
      optimizationPromise,
      30000, // 30 seconds
      'Route optimization timed out after 30 seconds. Google API may be slow or unreachable.'
    );

    // Detect conflicts
    const conflicts = detectConflicts(optimizedSessions);

    const route = {
      route_id: uuidv4(),
      agent_id,
      date,
      sessions: optimizedSessions,
      conflicts,
      total_sessions: optimizedSessions.length,
      generated_at: new Date().toISOString()
    };

    // Store route
    dailyRoutes.set(`${agent_id}-${date}`, route);

    console.log('Optimized route:', {
      date,
      sessions: route.total_sessions,
      conflicts: conflicts.length
    });

    res.json(route);
  } catch (error) {
    console.error('Error optimizing route:', error);
    res.status(500).json({ error: error.message });
  }
});

// ============================================
// IMAGE PARSING WITH OPENAI VISION
// ============================================

// Parse BrokerBay screenshots to extract property showings
app.post('/api/tours/parse-images', upload.array('images', 10), async (req, res) => {
  try {
    if (!openai) {
      return res.status(503).json({
        error: 'OpenAI API not configured. Please set OPENAI_API_KEY environment variable.'
      });
    }

    if (!req.files || req.files.length === 0) {
      return res.status(400).json({ error: 'No images uploaded' });
    }

    const { targetDate } = req.body; // "today", "tomorrow", specific date, or "any"

    console.log(`📸 Processing ${req.files.length} BrokerBay screenshot(s)...`);

    // Convert images to base64 for OpenAI Vision API
    const imageMessages = req.files.map(file => ({
      type: 'image_url',
      image_url: {
        url: `data:${file.mimetype};base64,${file.buffer.toString('base64')}`,
        detail: 'high' // High detail for better text extraction
      }
    }));

    // Determine target date for filtering
    const currentDate = new Date();
    const allowAnyDate = targetDate === 'any';
    let filterDate = null;

    if (!allowAnyDate) {
      if (targetDate === 'today') {
        filterDate = currentDate;
      } else if (targetDate === 'tomorrow') {
        filterDate = new Date(currentDate.getTime() + 24 * 60 * 60 * 1000);
      } else if (targetDate) {
        filterDate = new Date(targetDate);
      } else {
        filterDate = currentDate;
      }
    }

    const targetDateStr = filterDate ? filterDate.toISOString().split('T')[0] : null;
    const currentYear = new Date().getFullYear();

    // Call OpenAI Vision API with GPT-4 Vision
    const response = await openai.chat.completions.create({
      model: 'gpt-4o', // Latest GPT-4 with vision
      messages: [
        {
          role: 'system',
          content: `You are a real estate showing schedule parser. Extract property showing details from BrokerBay screenshots.

IMPORTANT RULES:
1. Focus ONLY on the schedule/calendar area showing property listings
2. Skip any properties with status "Denied" or "Cancelled"
3. Extract: date, time, full address (street + city), unit number (if present), status
4. Assume year is ${currentYear}
5. Return ONLY valid JSON array, no markdown formatting
6. If uncertain about any field, use null
7. Sort by date and time (chronological order)

Return format:
[
  {
    "date": "2025-01-15",
    "time": "10:00 AM",
    "address": "123 Main St, Toronto",
    "unit": "Unit 405",
    "status": "Confirmed"
  }
]`
        },
        {
          role: 'user',
          content: [
            {
              type: 'text',
              text: filterDate
                ? `Extract all property showings from these BrokerBay screenshot(s). Focus on ${targetDateStr}. Return valid JSON array only.`
                : 'Extract all property showings from these BrokerBay screenshot(s). Include every date that appears in the schedule. Return valid JSON array only.'
            },
            ...imageMessages
          ]
        }
      ],
      max_tokens: 4000,
      temperature: 0.1 // Low temperature for consistent extraction
    });

    const rawContent = response.choices[0]?.message?.content;

    if (!rawContent) {
      throw new Error('No response from OpenAI');
    }

    console.log('OpenAI raw response:', rawContent);

    // Parse JSON (handle markdown code blocks if present)
    let parsedData;
    try {
      // Remove markdown code blocks if present
      const jsonMatch = rawContent.match(/```(?:json)?\s*([\s\S]*?)```/) || rawContent.match(/\[[\s\S]*\]/);
      const jsonStr = jsonMatch ? (jsonMatch[1] || jsonMatch[0]) : rawContent;
      parsedData = JSON.parse(jsonStr.trim());
    } catch (parseError) {
      console.error('Failed to parse OpenAI response:', rawContent);
      throw new Error('Failed to parse extracted data. Please try again.');
    }

    if (!Array.isArray(parsedData)) {
      throw new Error('Invalid response format from OpenAI');
    }

    // Filter and validate properties
    const validProperties = [];
    const warnings = [];
    const todayMidnight = new Date().setHours(0, 0, 0, 0);
    const allowPastDates = allowAnyDate;

    for (const prop of parsedData) {
      // Skip if missing required fields
      if (!prop.date || !prop.time || !prop.address) {
        warnings.push(`Skipped incomplete entry: ${JSON.stringify(prop)}`);
        continue;
      }

      // Parse date
      const propDate = new Date(prop.date);

      // Skip past dates
      if (!allowPastDates && propDate < todayMidnight) {
        warnings.push(`Skipped past date: ${prop.date} ${prop.time} - ${prop.address}`);
        continue;
      }

      // Skip denied/cancelled
      if (prop.status && /denied|cancelled|canceled/i.test(prop.status)) {
        warnings.push(`Skipped ${prop.status}: ${prop.date} ${prop.time} - ${prop.address}`);
        continue;
      }

      // Geocode address (optional - can be done later during tour creation)
      validProperties.push({
        date: prop.date,
        time: prop.time,
        address: prop.address,
        unit: prop.unit || null,
        status: prop.status || 'Confirmed',
        notes: prop.notes || ''
      });
    }

    console.log(`✅ Extracted ${validProperties.length} valid properties (${warnings.length} skipped)`);

    res.json({
      success: true,
      properties: validProperties,
      warnings,
      totalExtracted: parsedData.length,
      validCount: validProperties.length,
      skippedCount: warnings.length
    });

  } catch (error) {
    console.error('❌ Image parsing error:', error);
    res.status(500).json({
      error: 'Failed to parse images',
      details: error.message
    });
  }
});

// Batch create tours from parsed properties
app.post('/api/tours/batch-create', async (req, res) => {
  try {
    const { agent_id = demoAgentId, tours } = req.body;

    if (!tours || !Array.isArray(tours) || tours.length === 0) {
      return res.status(400).json({ error: 'Missing required field: tours array' });
    }

    ensureAgent(agent_id); // Validate agent exists
    const createdSessions = [];
    const errors = [];

    for (let i = 0; i < tours.length; i++) {
      const tour = tours[i];

      if (!tour.client_id || !tour.date || !tour.properties || tour.properties.length === 0) {
        errors.push({
          tourIndex: i,
          error: 'Missing required fields: client_id, date, or properties'
        });
        continue;
      }

      try {
        const client = clients.get(tour.client_id);
        if (!client) {
          errors.push({
            tourIndex: i,
            error: `Client not found: ${tour.client_id}`
          });
          continue;
        }

        if (sessionExistsForClient(agent_id, tour.client_id, tour.date)) {
          errors.push({
            tourIndex: i,
            error: `Tour already exists for this client on ${tour.date}`
          });
          continue;
        }

        const cleanedProperties = mergePropertiesForStorage(tour.properties);
        if (!cleanedProperties.length) {
          errors.push({
            tourIndex: i,
            error: 'No valid properties found for this tour'
          });
          continue;
        }

        // Parse start time from first property
        const firstProp = cleanedProperties[0];
        const startTime = new Date(`${tour.date}T${convertTo24Hour(firstProp.time)}`);

        // Create session
        const sessionId = uuidv4();
        const session = {
          id: sessionId,
          agent_id,
          client_id: tour.client_id,
          date: tour.date,
          start_time: startTime.toISOString(),
          include_pickup: tour.include_pickup !== false, // Default to true
          properties: cleanedProperties.map((prop, idx) => {
            // Try to geocode or use mock coordinates
            return {
              id: uuidv4(),
              address: prop.address,
              unit: prop.unit || null,
              lat: null, // Will be geocoded during optimization
              lng: null,
              order: idx,
              status: prop.status || 'Confirmed',
              notes: prop.notes || ''
            };
          }),
          created_at: new Date().toISOString(),
          status: 'Scheduled'
        };

        // Geocode addresses
        for (const property of session.properties) {
          const fullAddress = property.unit
            ? `${property.unit}, ${property.address}`
            : property.address;

          const coords = await resolveCoordinates(null, null, fullAddress);
          property.lat = coords.lat;
          property.lng = coords.lng;
        }

        showingSessions.set(sessionId, session);
        await saveSession(session);

        createdSessions.push(session);

      } catch (error) {
        errors.push({
          tourIndex: i,
          error: error.message
        });
      }
    }

    console.log(`✅ Created ${createdSessions.length} tours (${errors.length} errors)`);

    const statusCode = createdSessions.length === 0 && errors.length > 0 ? 409 : 200;
    res.status(statusCode).json({
      success: errors.length === 0,
      sessions: createdSessions,
      errors,
      created: createdSessions.length,
      failed: errors.length
    });

  } catch (error) {
    console.error('❌ Batch tour creation error:', error);
    res.status(500).json({ error: error.message });
  }
});

// Helper: Convert 12-hour time to 24-hour format
function convertTo24Hour(time12h) {
  if (!time12h) return '09:00';

  const [time, modifier] = time12h.trim().split(/\s+/);
  let [hours, minutes] = time.split(':');

  if (!hours || !minutes) return '09:00';

  hours = parseInt(hours, 10);

  if (modifier && modifier.toLowerCase() === 'pm' && hours !== 12) {
    hours += 12;
  } else if (modifier && modifier.toLowerCase() === 'am' && hours === 12) {
    hours = 0;
  }

  return `${String(hours).padStart(2, '0')}:${minutes}`;
}

// Get optimized route for a date
app.get('/api/routes', (req, res) => {
  const { agent_id = demoAgentId, date } = req.query;

  if (!date) {
    return res.status(400).json({ error: 'Missing required parameter: date' });
  }

  const route = dailyRoutes.get(`${agent_id}-${date}`);

  if (!route) {
    return res.status(404).json({ error: 'No route found for this date. Run optimization first.' });
  }

  res.json(route);
});

// ============================================
// SOCKET.IO - REAL-TIME LOCATION TRACKING
// ============================================

io.on('connection', (socket) => {
  console.log('Client connected:', socket.id);

  socket.on('agent-location-update', (data) => {
    const { agent_id, latitude, longitude, timestamp } = data;

    agentLocations.set(agent_id, {
      latitude,
      longitude,
      timestamp: timestamp || new Date().toISOString(),
      updated_at: new Date().toISOString()
    });

    // Broadcast to all connected clients (for future live tracking)
    io.emit('location-update', {
      agent_id,
      location: { lat: latitude, lng: longitude },
      timestamp
    });
  });

  socket.on('disconnect', () => {
    console.log('Client disconnected:', socket.id);
  });
});

// ============================================
// START SERVER
// ============================================

const PORT = process.env.PORT || 3000;

async function startServer() {
  try {
    await connectToDatabase();
    await hydrateFromDatabase();
  } catch (error) {
    console.warn('⚠️  Database initialization issue:', error.message);
  }

  server.listen(PORT, () => {
    console.log('');
    console.log('═══════════════════════════════════════════════');
    console.log('AgentFlow MVP Backend Server Running');
    console.log('═══════════════════════════════════════════════');
    console.log(`Server: http://localhost:${PORT}`);
    console.log(`Health: http://localhost:${PORT}/api/health`);
    console.log(`Demo Agent ID: ${demoAgentId}`);
    console.log(`Demo Clients: ${demoClients.length} seeded`);
    console.log('CORS allowed origins:', corsSummary);
    console.log('═══════════════════════════════════════════════');
    console.log('');
  });
}

startServer();