/* Offline migration, invoked by an operator in mongosh. Default is read-only.
   const {migrate}=require('C:/.../activityConfig/migrate.cjs'); await migrate(db,{apply:false}); */
const { createHash } = require('node:crypto');
const key = (...parts) => createHash('sha256').update(JSON.stringify(parts)).digest('hex');
const same = (a,b) => JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
function canonical(v) {
  if (Array.isArray(v)) return v.map(canonical);
  if (v && typeof v === 'object' && !(v instanceof Date)) return Object.fromEntries(Object.keys(v).sort().map(k=>[k,canonical(v[k])]));
  return v;
}
async function migrate(db, {apply=false}={}) {
  const collection = name => typeof db.getCollection==='function' ? db.getCollection(name) : db.collection(name);
  const read = name => collection(name).find({}).toArray();
  const merge = async names => {
    const rows=new Map();
    for(const name of names) for(const row of await read(name)) {
      if(rows.has(row._id) && !same(rows.get(row._id),row)) {
        if(name==='gold_miner_player_periods') {
          const current=rows.get(row._id), migrated=new Set(['initialized','entitlement','entitlementNextRetryAt','settlementId',
            'settlementPreparedAt','settlementAcknowledgedAt','settlementNextRetryAt']);
          if(Object.keys(row).every(k=>migrated.has(k)||same(current[k],row[k]))) continue;
        }
        throw Error('Conflicting source rows: '+name+'/'+row._id);
      }
      rows.set(row._id,row);
    }
    return rows;
  };
  const operations=[];
  const configs=new Map((await read('activityConfigs')).map(r=>[r._id,r]));
  const originalPlayers=new Map((await read('goldMinerPlayerPeriods')).map(r=>[r._id,r]));
  const players=await merge(['goldMinerPlayerPeriods','gold_miner_player_periods']);
  // Copy before modifying so a dry-run does not mutate driver/mock source objects.
  for(const [id,row] of players) players.set(id,structuredClone(row));
  const addConfig = row => {
    const old=configs.get(row._id);
    if(old && !same(old,row)) throw Error('Configuration conflict: '+row._id);
    if(!old) { configs.set(row._id,row); operations.push({table:'activityConfigs',row}); }
  };
  for(const c of (await merge(['goldMinerConfigs','gold_miner_configs'])).values()) {
    const { _id,status,createdAt,configVersion,publishedAt,...config }=c;
    const effectiveFrom=Date.parse(config.effectiveFromPeriodId?.slice(10)+'T00:00:00+08:00');
    if(!Number.isFinite(effectiveFrom) || !configVersion || !Number.isSafeInteger(publishedAt)) throw Error('Invalid gold miner config: '+_id);
    addConfig({_id:key('goldMiner',configVersion),activityId:'goldMiner',recordType:'version',configVersion,
      status:status||'published',effectiveFrom,publishedAt,config});
  }
  for(const p of (await merge(['goldMinerPeriods','gold_miner_periods'])).values()) {
    if(!p.configSnapshot || !p.periodId) throw Error('Invalid period: '+p._id);
    addConfig({_id:key('goldMinerControl',p.periodId),activityId:'goldMiner',recordType:'control',periodId:p.periodId,
      purchaseEnabled:p.purchaseEnabled!==false,frozenConfig:p.configSnapshot});
  }
  for(const c of await read('cloudRiseConfig')) {
    if(typeof c.periodId!=='string' || !Number.isSafeInteger(c.startsAt) || !Number.isSafeInteger(c.endsAt)
      || c.startsAt>=c.endsAt) throw Error('Invalid cloudRise config: '+c._id);
    const configVersion='legacy:'+c.periodId;
    addConfig({_id:key('cloudRise',configVersion),activityId:'cloudRise',recordType:'version',configVersion,status:'published',
      effectiveFrom:c.startsAt,publishedAt:c.startsAt-1,config:{periodId:c.periodId,startsAt:c.startsAt,endsAt:c.endsAt,
        unlockLevel:c.unlockLevel,durationHours:c.durationHours??24,pools:c.pools??[10000,15000,20000]}});
  }
  for(const e of (await merge(['goldMinerEntitlements','gold_miner_entitlements'])).values()) {
    const id=key('users',e.uid,e.targetPeriodId);
    let p=players.get(id);
    if(!p) {
      if(e.state!=='reserved') throw Error('Active entitlement missing player: '+e._id);
      const startsAt=Date.parse(e.targetPeriodId.slice(10)+'T00:00:00+08:00');
      if(!Number.isFinite(startsAt)) throw Error('Invalid entitlement period: '+e._id);
      p={_id:id,uid:e.uid,accountScope:'users',periodId:e.targetPeriodId,startsAt,endsAt:startsAt+4*86400000,
        entitlementStatus:'none',revision:0,createdAt:e.createdAt};players.set(id,p);
    }
    if(p.entitlement && p.entitlement.sourceOrderNo!==e.sourceOrderNo) throw Error('Entitlement conflict: '+id);
    // Never regress an embedded entitlement on a repeated migration.
    if(!p.entitlement) p.entitlement=structuredClone(e);
    p.entitlementNextRetryAt??=0;
  }
  for(const g of (await merge(['goldMinerRewardGrants','gold_miner_reward_grants'])).values()) {
    const p=players.get(key('users',g.uid,g.periodId)), task=p?.tasks?.find(t=>t.taskId===g.taskId);
    if(!task || task.grantId!==g._id || !same(task.itemsSnapshot,g.itemsSnapshot)
      || (g.status==='client_saved' && task.claimStatus!=='claimed')) throw Error('Reward/player mismatch: '+g._id);
  }
  for(const r of (await merge(['goldMinerSettlements','gold_miner_settlements'])).values()) {
    const p=players.get(key('users',r.uid,r.periodId));
    if(!p || r._id!==key('settlement',p._id) || !same(p.settlementTaskIds,r.taskIds)) throw Error('Settlement/player mismatch: '+r._id);
    p.settlementAcknowledgedAt??=r.acknowledgedAt??null;
  }
  for(const p of players.values()) {
    if(p._id!==key('users',p.uid,p.periodId)) throw Error('Invalid player identity: '+p._id);
    if(p.tasks) {
      p.initialized=true;
      p.settlementId=key('settlement',p._id);
      p.settlementAcknowledgedAt??=null;
      // Old unpaid closures must be rechecked after a later payment; old unassigned tasks need server authorization.
      if(!p.settlementPreparedAt || p.tasks.some(t=>p.settlementTaskIds?.includes(t.taskId)&&t.claimStatus==='unclaimed')) p.settlementPreparedAt=null;
      p.settlementNextRetryAt??=0;
      if(p.entitlementStatus==='unlocked' && !p.entitlement) throw Error('Unlocked player missing entitlement: '+p._id);
    }
    if(!same(originalPlayers.get(p._id),p)) operations.push({table:'goldMinerPlayerPeriods',row:p});
  }
  // Validate every source before any write. Never delete old collections or touch users/order.
  if(apply) for(const op of operations) {
    const {_id,...fields}=op.row;
    await collection(op.table).updateOne({_id},{$set:fields},{upsert:true});
  }
  return {dryRun:!apply,activityConfigs:configs.size,playerPeriods:players.size,writes:operations.length,
    oldCollectionsDeleted:false};
}
module.exports={migrate};