breedr/server/routes/pedigree.js

const express = require('express');
const router = express.Router();
const { getDatabase } = require('../db/init');

const MAX_CACHE_SIZE = 1000;
const ancestorCache = new Map();
const coiCache = new Map();

function getFromCache(cache, key, computeFn) {
  if (cache.has(key)) {
    const val = cache.get(key);
    cache.delete(key);
    cache.set(key, val);
    return val;
  }
  const val = computeFn();
  if (cache.size >= MAX_CACHE_SIZE) {
    cache.delete(cache.keys().next().value);
  }
  cache.set(key, val);
  return val;
}

/**
 * getAncestorMap(db, dogId, maxGen)
 * Returns Map<id, [{ id, name, generation }, ...]>
 * INCLUDES dogId itself at generation 0 so direct parent-offspring
 * pairings are correctly detected by calculateCOI.
 */
function getAncestorMap(db, dogId, maxGen = 6) {
  const cacheKey = `${dogId}-${maxGen}`;
  return getFromCache(ancestorCache, cacheKey, () => {
    const map = new Map();

    function recurse(id, gen) {
      if (gen > maxGen) return;
      const dog = db.prepare('SELECT id, name FROM dogs WHERE id = ?').get(id);
      if (!dog) return;
      if (!map.has(id)) map.set(id, []);
      map.get(id).push({ id: dog.id, name: dog.name, generation: gen });
      if (map.get(id).length === 1) {
        const parents = db.prepare(`
          SELECT p.parent_id FROM parents p WHERE p.dog_id = ?
        `).all(id);
        parents.forEach(p => recurse(p.parent_id, gen + 1));
      }
    }

    recurse(parseInt(dogId), 0);
    return map;
  });
}

/**
 * isDirectRelation(db, sireId, damId)
 * Returns { related, relationship } if one dog is a direct ancestor
 * of the other within 3 generations.
 */
function isDirectRelation(db, sireId, damId) {
  const sid = parseInt(sireId);
  const did = parseInt(damId);
  const sireMap = getAncestorMap(db, sid, 3);
  const damMap  = getAncestorMap(db, did, 3);

  if (damMap.has(sid)) {
    const gen = damMap.get(sid)[0].generation;
    const label = gen === 1 ? 'parent' : gen === 2 ? 'grandparent' : `generation-${gen} ancestor`;
    return { related: true, relationship: `Sire is the ${label} of the selected dam` };
  }
  if (sireMap.has(did)) {
    const gen = sireMap.get(did)[0].generation;
    const label = gen === 1 ? 'parent' : gen === 2 ? 'grandparent' : `generation-${gen} ancestor`;
    return { related: true, relationship: `Dam is the ${label} of the selected sire` };
  }
  return { related: false, relationship: null };
}

/**
 * calculateCOI(db, sireId, damId)
 * Wright Path Coefficient method.
 * Dogs included at gen 0 in their own maps so parent x offspring
 * yields ~25% COI.
 *
 * Fix: do NOT exclude sid/did from commonIds globally.
 * - Exclude `did` from sireMap keys  (the dam itself can't be a
 *   common ancestor of the sire's side for THIS pairing's offspring)
 * - Exclude `sid` from damMap keys   (same logic for sire)
 * This preserves the case where the sire IS a common ancestor in the
 * dam's ancestry (parent x offspring) while still avoiding reflexive
 * self-loops.
 */
function calculateCOI(db, sireId, damId) {
  const cacheKey = `${sireId}-${damId}`;
  return getFromCache(coiCache, cacheKey, () => {
    const sid = parseInt(sireId);
    const did = parseInt(damId);
    const sireMap = getAncestorMap(db, sid);
    const damMap  = getAncestorMap(db, did);

    // Common ancestors: in BOTH maps, but:
    //   - not the dam itself appearing in sireMap (would be a loop)
    //   - not the sire itself appearing in damMap already handled below
    // We collect all IDs present in both, excluding only the direct
    // subjects (did from sireMap side, sid excluded already since we
    // iterate sireMap keys — but sid IS in sireMap at gen 0, and if
    // damMap also has sid, that is the parent×offspring case we WANT).
    const commonIds = [...sireMap.keys()].filter(
      id => damMap.has(id) && id !== did
    );

    let coi = 0;
    const processedPaths = new Set();
    const commonAncestorList = [];

    commonIds.forEach(ancId => {
      const sireOccs = sireMap.get(ancId);
      const damOccs  = damMap.get(ancId);

      sireOccs.forEach(so => {
        damOccs.forEach(do_ => {
          const key = `${ancId}-${so.generation}-${do_.generation}`;
          if (!processedPaths.has(key)) {
            processedPaths.add(key);
            coi += Math.pow(0.5, so.generation + do_.generation + 1);
          }
        });
      });

      const closestSire = sireOccs.reduce((a, b) => a.generation < b.generation ? a : b);
      const closestDam  = damOccs.reduce((a, b)  => a.generation < b.generation ? a : b);
      commonAncestorList.push({
        id:      ancId,
        name:    sireOccs[0].name,
        sireGen: closestSire.generation,
        damGen:  closestDam.generation
      });
    });

    return {
      coefficient:     coi,
      commonAncestors: commonAncestorList
    };
  });
}

// =====================================================================
// IMPORTANT: Specific named routes MUST be registered BEFORE
// the /:id wildcard, or Express will match 'relations' and
// 'trial-pairing' as dog IDs and return 404/wrong data.
// =====================================================================

const handleTrialPairing = (req, res) => {
  try {
    const { sire_id, dam_id } = req.body;
    if (!sire_id || !dam_id) {
      return res.status(400).json({ error: 'Both sire_id and dam_id are required' });
    }

    const db = getDatabase();
    const sire = db.prepare("SELECT * FROM dogs WHERE id = ? AND sex = 'male'").get(sire_id);
    const dam  = db.prepare("SELECT * FROM dogs WHERE id = ? AND sex = 'female'").get(dam_id);

    if (!sire || !dam) {
      return res.status(404).json({ error: 'Invalid sire or dam \u2014 check sex values in database' });
    }

    const relation = isDirectRelation(db, sire_id, dam_id);
    const result   = calculateCOI(db, sire_id, dam_id);

    res.json({
      sire:            { id: sire.id, name: sire.name },
      dam:             { id: dam.id,  name: dam.name  },
      coi:             result.coefficient,
      commonAncestors: result.commonAncestors,
      directRelation:  relation.related ? relation.relationship : null,
      recommendation:  result.coefficient < 0.05 ? 'Low risk'
                     : result.coefficient < 0.10 ? 'Moderate risk'
                     :                           'High risk'
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// POST /api/pedigree/trial-pairing
router.post('/trial-pairing', handleTrialPairing);

// POST /api/pedigree/coi
router.post('/coi', handleTrialPairing);

// GET /api/pedigree/:id/coi
router.get('/:id/coi', (req, res) => {
  try {
    const db = getDatabase();
    const parents = db.prepare('SELECT parent_type, parent_id FROM parents WHERE dog_id = ?').all(req.params.id);
    const sire = parents.find(p => p.parent_type === 'sire');
    const dam  = parents.find(p => p.parent_type === 'dam');

    if (!sire || !dam) {
      return res.json({ coi: 0, commonAncestors: [], message: 'Incomplete parent data' });
    }

    const result = calculateCOI(db, sire.parent_id, dam.parent_id);
    res.json({
      coi: result.coefficient,
      commonAncestors: result.commonAncestors
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// GET /api/pedigree/relations/:sireId/:damId
router.get('/relations/:sireId/:damId', (req, res) => {
  try {
    const db = getDatabase();
    res.json(isDirectRelation(db, req.params.sireId, req.params.damId));
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// GET /api/pedigree/:id/cancer-lineage
router.get('/:id/cancer-lineage', (req, res) => {
  try {
    const db = getDatabase();
    // Get ancestor map up to 5 generations
    const ancestorMap = getAncestorMap(db, req.params.id, 5);
    
    // Collect all unique ancestor IDs
    const ancestorIds = Array.from(ancestorMap.keys());
    
    if (ancestorIds.length === 0) {
      return res.json({ lineage_cases: [], stats: { total_ancestors: 0, ancestors_with_cancer: 0 } });
    }
    
    // Query cancer history for all ancestors
    const placeholders = ancestorIds.map(() => '?').join(',');
    const cancerRecords = db.prepare(`
      SELECT c.*, d.name, d.sex 
      FROM cancer_history c
      JOIN dogs d ON c.dog_id = d.id
      WHERE c.dog_id IN (${placeholders})
    `).all(...ancestorIds);
    
    // Structure the response
    const cases = cancerRecords.map(record => {
      // Find the closest generation this ancestor appears in
      const occurrences = ancestorMap.get(record.dog_id);
      const closestGen = occurrences.reduce((min, occ) => occ.generation < min ? occ.generation : min, 999);
      
      return {
        ...record,
        generation_distance: closestGen
      };
    });
    
    // Sort by generation distance (closer relatives first)
    cases.sort((a, b) => a.generation_distance - b.generation_distance);
    
    // Count unique dogs with cancer (excluding generation 0 if we only want stats on ancestors)
    const ancestorCases = cases.filter(c => c.generation_distance > 0);
    const uniqueAncestorsWithCancer = new Set(ancestorCases.map(c => c.dog_id)).size;
    
    // Number of ancestors is total unique IDs minus 1 for the dog itself
    const numAncestors = ancestorIds.length > 0 && ancestorMap.get(parseInt(req.params.id)) ? ancestorIds.length - 1 : ancestorIds.length;
    
    res.json({
      lineage_cases: cases,
      stats: {
        total_ancestors: numAncestors,
        ancestors_with_cancer: uniqueAncestorsWithCancer
      }
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// =====================================================================
// Wildcard routes last
// =====================================================================

// GET /api/pedigree/:id
router.get('/:id', (req, res) => {
  try {
    const db = getDatabase();
    const generations = parseInt(req.query.generations) || 5;

    function buildTree(dogId, currentGen = 0) {
      if (currentGen >= generations) return null;
      const dog = db.prepare('SELECT * FROM dogs WHERE id = ?').get(dogId);
      if (!dog) return null;
      dog.photo_urls = dog.photo_urls ? JSON.parse(dog.photo_urls) : [];
      const parents = db.prepare('SELECT parent_type, parent_id FROM parents WHERE dog_id = ?').all(dogId);
      const sire = parents.find(p => p.parent_type === 'sire');
      const dam  = parents.find(p => p.parent_type === 'dam');
      return {
        ...dog,
        generation: currentGen,
        sire: sire ? buildTree(sire.parent_id, currentGen + 1) : null,
        dam:  dam  ? buildTree(dam.parent_id,  currentGen + 1) : null
      };
    }

    const tree = buildTree(req.params.id);
    if (!tree) return res.status(404).json({ error: 'Dog not found' });
    res.json(tree);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// GET /api/pedigree/:id/descendants
router.get('/:id/descendants', (req, res) => {
  try {
    const db = getDatabase();
    const generations = parseInt(req.query.generations) || 3;

    function buildDescendantTree(dogId, currentGen = 0) {
      if (currentGen >= generations) return null;
      const dog = db.prepare('SELECT * FROM dogs WHERE id = ?').get(dogId);
      if (!dog) return null;
      dog.photo_urls = dog.photo_urls ? JSON.parse(dog.photo_urls) : [];
      const offspring = db.prepare(`
        SELECT DISTINCT d.id, d.name, d.sex, d.birth_date
        FROM dogs d JOIN parents p ON d.id = p.dog_id
        WHERE p.parent_id = ? AND d.is_active = 1
      `).all(dogId);
      return {
        ...dog,
        generation: currentGen,
        offspring: offspring.map(c => buildDescendantTree(c.id, currentGen + 1))
      };
    }

    const tree = buildDescendantTree(req.params.id);
    if (!tree) return res.status(404).json({ error: 'Dog not found' });
    res.json(tree);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

module.exports = router;