// rank-checker/server/routes/rank.js
// ─────────────────────────────────────────────────────────────
// ROOT CAUSE FIXES:
// 1. Added pws=0  → disables personalization (critical!)
// 2. Added num=100 → fetch 100 results to find deep rankings
// 3. Added location param → city/state level targeting
// 4. Organic-only parsing → skip ads, knowledge panels, maps
// 5. domain.includes() → partial match to catch www + non-www
// 6. US default → no global/personalized results
// ─────────────────────────────────────────────────────────────
const express = require('express');
const axios = require('axios');
const RankHistory = require('../models/RankHistory');
const rateLimit = require('express-rate-limit');
const router = express.Router();

// ── Supported locations ONLY (no global/irrelevant regions) ──
const ALLOWED_COUNTRIES = {
  us: { gl: 'us', hl: 'en', location: 'United States', cr: 'countryUS' },
  gb: { gl: 'gb', hl: 'en', location: 'United Kingdom', cr: 'countryGB' },
  ca: { gl: 'ca', hl: 'en', location: 'Canada',         cr: 'countryCA' },
  au: { gl: 'au', hl: 'en', location: 'Australia',       cr: 'countryAU' },
};

const limiter = rateLimit({ windowMs: 60000, max: 30 });
router.use(limiter);

// POST /api/rank/check
router.post('/check', async (req, res) => {
  const { domain, keywords, country = 'us', device = 'desktop' } = req.body;

  // Validate country — reject unsupported regions
  if (!ALLOWED_COUNTRIES[country])
    return res.status(400).json({ error: 'Unsupported country. Use: us, gb, ca, au' });
  if (!domain || !keywords?.length)
    return res.status(400).json({ error: 'domain + keywords required' });

  const geo = ALLOWED_COUNTRIES[country];

  // Process in batches of 10 (parallel)
  const results = [];
  for (let i = 0; i < keywords.length; i += 10) {
    const chunk = keywords.slice(i, i + 10);
    const batch = await Promise.allSettled(
      chunk.map(kw => checkKeyword(domain, kw, geo, device))
    );
    batch.forEach((r, j) => results.push({
      keyword: chunk[j],
      ...(r.status === 'fulfilled' ? r.value : { position: null, error: r.reason?.message })
    }));
  }

  await RankHistory.create({ domain, country, geo, checkedAt: new Date(), results });
  res.json({ success: true, domain, country, location: geo.location, results });
});

async function checkKeyword(domain, keyword, geo, device) {
  const { data } = await axios.get('https://serpapi.com/search', {
    params: {
      q:        keyword,
      gl:       geo.gl,         // FIX 1: geo-country code (us/gb/ca/au)
      hl:       geo.hl,         // FIX 2: language = English always
      cr:       geo.cr,         // FIX 3: countryUS/GB/CA/AU filter
      location: geo.location,   // FIX 4: city/country name for accuracy
      pws:      '0',            // FIX 5: disable personalization (CRITICAL)
      safe:     'off',          // FIX 6: no safe search bias
      num:      '100',          // FIX 7: get 100 results (find deep ranks)
      device:   device,          // desktop or mobile
      no_cache: 'true',         // FIX 8: always fresh results
      api_key:  process.env.SERPAPI_KEY,
      output:   'json',
    }
  });

  // FIX 9: Parse ONLY organic_results — skip ads, shopping, local pack
  const organics = data.organic_results || [];
  let position = null, rankingUrl = null;

  const cleanDomain = domain.replace(/^(https?:\/\/)?(www\.)?/, '').toLowerCase();

  organics.forEach((result, idx) => {
    if (position) return; // stop after first match
    const resLink = result.link.replace(/^(https?:\/\/)?(www\.)?/, '').toLowerCase();
    // FIX 10: match www + non-www versions of domain
    if (resLink.startsWith(cleanDomain) || resLink.includes(`/${cleanDomain}/`)) {
      position = idx + 1;
      rankingUrl = result.link;
    }
  });

  // Detect SERP features (organic only — not ads)
  const serpFeatures = [];
  const fs = data.featured_snippet;
  if (fs?.link?.includes(cleanDomain)) serpFeatures.push('featured');
  if (data.local_results?.places?.some(p => p.website?.includes(cleanDomain))) serpFeatures.push('map');
  if (data.knowledge_graph?.website?.includes(cleanDomain)) serpFeatures.push('knowledge');

  return { position, rankingUrl, serpFeatures, totalResults: organics.length };
}

module.exports = router;

# rank_checker/api/rank.py — Accurate location-based rank checking
# ROOT CAUSE FIXES applied (same as Node.js version)
import requests, os
from flask import Flask, request, jsonify
from pymongo import MongoClient
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor
import re

app = Flask(__name__)
db = MongoClient(os.getenv('MONGODB_URI')).rank_checker

# Allowed countries only — no global/irrelevant regions
ALLOWED_COUNTRIES = {
  'us': {'gl':'us', 'hl':'en', 'location':'United States', 'cr':'countryUS'},
  'gb': {'gl':'gb', 'hl':'en', 'location':'United Kingdom', 'cr':'countryGB'},
  'ca': {'gl':'ca', 'hl':'en', 'location':'Canada',         'cr':'countryCA'},
  'au': {'gl':'au', 'hl':'en', 'location':'Australia',       'cr':'countryAU'},
}

def clean_domain(domain):
    return re.sub(r'^(https?://)?(www\.)?', '', domain).lower()

def check_keyword(domain, keyword, geo):
    clean = clean_domain(domain)
    resp = requests.get('https://serpapi.com/search', params={
        'q':        keyword,
        'gl':       geo['gl'],       # FIX 1: country code
        'hl':       geo['hl'],       # FIX 2: language = English
        'cr':       geo['cr'],       # FIX 3: country restrict
        'location': geo['location'], # FIX 4: precise location
        'pws':      '0',             # FIX 5: no personalization
        'safe':     'off',           # FIX 6: no safe search bias
        'num':      '100',           # FIX 7: fetch 100 results
        'no_cache': 'true',          # FIX 8: always fresh
        'api_key':  os.environ['SERPAPI_KEY']
    }, timeout=15)

    data = resp.json()
    # FIX 9: organic_results ONLY — skip ads, shopping, local
    organics = data.get('organic_results', [])

    position, url = None, None
    for i, r in enumerate(organics):
        # FIX 10: match www + non-www
        res_link = clean_domain(r.get('link', ''))
        if res_link.startswith(clean) or clean in res_link:
            position, url = i + 1, r['link']
            break

    features = []
    fs = data.get('featured_snippet', {})
    if clean in clean_domain(fs.get('link', '')): features.append('featured')
    if data.get('local_results'): features.append('local_pack')

    return {'keyword': keyword, 'position': position,
            'ranking_url': url, 'serp_features': features}

@app.route('/api/rank/check', methods=['POST'])
def check_rank():
    body = request.get_json()
    domain   = body['domain']
    keywords = body['keywords']
    country  = body.get('country', 'us')

    if country not in ALLOWED_COUNTRIES:
        return jsonify({'error':'Unsupported country. Use: us, gb, ca, au'}), 400

    geo = ALLOWED_COUNTRIES[country]
    with ThreadPoolExecutor(max_workers=10) as ex:
        results = list(ex.map(lambda kw: check_keyword(domain, kw, geo), keywords))

    db.rank_history.insert_one({
        'domain': domain, 'country': country,
        'location': geo['location'],
        'checked_at': datetime.utcnow(), 'results': results
    })
    return jsonify({'success': True, 'location': geo['location'], 'results': results})

// models/RankHistory.js
const { Schema, model } = require('mongoose');
const resultSchema = new Schema({
  keyword: String, position: Number,
  rankingUrl: String, serpFeatures: [String], change: Number
});
const historySchema = new Schema({
  domain: { type: String, required: true, index: true },
  country: { type: String, default: 'us' },
  checkedAt: { type: Date, default: Date.now, index: true },
  results: [resultSchema]
}, { timestamps: true });
historySchema.index({ domain: 1, checkedAt: -1 });
module.exports = model('RankHistory', historySchema);

// routes/export.js — CSV export
const { Parser } = require('json2csv');
router.get('/export/csv/:domain', async (req, res) => {
  const doc = await RankHistory
    .findOne({ domain: req.params.domain }).sort({ checkedAt: -1 });
  const csv = new Parser({ fields:['keyword','position','rankingUrl','change'] })
    .parse(doc.results);
  res.setHeader('Content-Type', 'text/csv');
  res.setHeader('Content-Disposition', `attachment; filename="${req.params.domain}.csv"`);
  res.send(csv);
});