import test from 'node:test';
import assert from 'node:assert/strict';
import { Tx, Script } from '@cmdcode/tapscript';
import { TestWallet } from '../src/adapters/wallet.js';
import { LocalChain, LocalRPC } from '../src/adapters/chain.js';
import { InscriptionAdapter, validateText } from '../src/adapters/inscription.js';
import { encodeLab, decodeLab } from '../src/storage.js';

function setup() {
  const wallet = TestWallet.create(), chain = new LocalChain();
  chain.mine(wallet.script);
  return { wallet, chain, ins: new InscriptionAdapter(chain, wallet) };
}
test('signed commit/reveal, owned collectible, confirmation, raw tx/block inspection and restoration', () => {
  const { wallet, chain, ins } = setup();
  assert.match(wallet.address, /^bcrt1p/);
  assert.equal(chain.balance(wallet.script), 5e9);
  const id = ins.inscribe('Hello from v0 🌱');
  assert.equal(chain.mempool.length, 2);
  assert.equal(chain.balance(wallet.script), 5e9 - 1000);
  assert.equal(ins.list()[0].height, null);
  assert.equal(ins.list()[0].id, id);
  assert.deepEqual(new InscriptionAdapter(chain, TestWallet.create()).list(), []);
  const pendingRestored = decodeLab(encodeLab({wallet,chain}));
  assert.equal(new InscriptionAdapter(pendingRestored.chain,pendingRestored.wallet).list()[0].id, id);
  const block = chain.mine(wallet.script);
  assert.equal(chain.mempool.length, 0);
  assert.equal(ins.list()[0].height, 2);
  assert.equal(chain.balance(wallet.script), 1e10 - 1000);
  const rpc = new LocalRPC(chain);
  const revealId = id.slice(0,-2);
  assert.equal(Tx.util.getTxid(rpc.call('getrawtransaction',[revealId])), revealId);
  assert.ok(rpc.call('getblock',[block.hash]).tx.includes(revealId));
  assert.equal(rpc.call('getblockhash',[2]),block.hash);
  assert.equal(rpc.call('getblockcount'),2);
  assert.throws(()=>rpc.call('sendrawtransaction'),/Unsupported/);
  const restored = decodeLab(encodeLab({wallet,chain}));
  assert.equal(restored.wallet.address,wallet.address);
  assert.deepEqual(new InscriptionAdapter(restored.chain,restored.wallet).list(),ins.list());
});
test('empty wallet, UTF-8 limit, and untagged/mainnet wallet imports rejected', () => {
  assert.throws(()=>new InscriptionAdapter(new LocalChain(),TestWallet.create()).inscribe('hi'), /Mine a block/);
  for (const bad of ['', '   ', '🌱'.repeat(71)]) assert.throws(()=>validateText(bad));
  assert.doesNotThrow(()=>validateText('🌱'.repeat(70)));
  assert.throws(()=>TestWallet.load({secret:'1'.repeat(64)}), /Only Super Testnet/);
  const backup = TestWallet.create().backup(); backup.network='mainnet';
  assert.throws(()=>TestWallet.load(backup), /Only Super Testnet/);
});
test('invalid reveal signature rolls back the entire package, and double-spends fail', () => {
  const {wallet,chain,ins} = setup();
  const before = chain.snapshot(); ins.inscribe('atomic');
  const [commit,reveal] = chain.mempool;
  const bad = Tx.decode(reveal); bad.vin[0].witness[0]='00'.repeat(64);
  const clean = new LocalChain(before);
  assert.throws(()=>clean.submitPackage([commit,Tx.encode(bad).hex]),/signature|Signature/);
  assert.deepEqual(clean.snapshot(),before);
  assert.equal(clean.balance(wallet.script),5e9);
  clean.submitPackage([commit,reveal]);
  assert.throws(()=>clean.submitPackage([commit]),/Duplicate/);
  const spend = Tx.decode(commit); spend.vout[1].value = Number(spend.vout[1].value)-1;
  assert.throws(()=>clean.submitPackage([Tx.encode(spend).hex]),/spent/);
});
test('tampering with reveal payload, control block or value is rejected', () => {
  const {chain,ins} = setup(); const before=chain.snapshot(); ins.inscribe('original');
  const [commit,reveal]=chain.mempool;
  for (const mutate of [
    tx=>{ const script=Script.decode(tx.vin[0].witness[1]); script[8]='6861636b6564'; tx.vin[0].witness[1]=Script.encode(script,false).hex; },
    tx=>{ tx.vin[0].witness[2]='c0'+'00'.repeat(32); },
    tx=>{ tx.vout[0].value=5000; },
  ]) {
    const tx=Tx.decode(reveal); mutate(tx); const candidate=new LocalChain(before);
    assert.throws(()=>candidate.submitPackage([commit,Tx.encode(tx).hex]));
    assert.deepEqual(candidate.snapshot(),before);
  }
});
test('collectibles are protected and subsequent inscriptions use change', () => {
  const {wallet,chain,ins}=setup(); const first=ins.inscribe('first'); ins.inscribe('second');
  assert.equal(ins.list().length,2);
  const record=chain.transactions.get(first.slice(0,-2));
  const spend=Tx.create({vin:[{txid:record.txid,vout:0,sequence:0xffffffff,prevout:record.tx.vout[0]}],vout:[{value:500,scriptPubKey:wallet.script}]});
  spend.vin[0].witness=[wallet.sign(spend)];
  assert.throws(()=>chain.submitPackage([Tx.encode(spend).hex]),/protects inscription/);
  chain.mine(wallet.script); assert.equal(ins.list().length,2);
});
test('corrupted persistence is rejected rather than silently reset', () => {
  assert.throws(()=>decodeLab('{bad'));
  const {chain}=setup(); const snapshot=chain.snapshot(); snapshot.blocks[0].hash='0'.repeat(64);
  assert.throws(()=>new LocalChain(snapshot),/block hash/);
  assert.throws(()=>new LocalChain({...snapshot,network:'mainnet'}),/network/);
});