import { Connection, PublicKey } from '@solana/web3.js';
import { Program, AnchorProvider } from '@coral-xyz/anchor';
import { useWallet } from '@solana/wallet-adapter-react';
import { encrypt } from './crypto';
 
export function CreateCapsule() {
  const wallet = useWallet();
  const [message, setMessage] = useState('');
  const [unlockDate, setUnlockDate] = useState('');
  
  const createCapsule = async () => {
    if (!wallet.connected) {
      throw new Error('Wallet not connected');
    }
    
    // Generate encryption key
    const encryptionKey = generateRandomKey();
    
    // Encrypt message
    const encrypted = await encrypt(message, encryptionKey);
    
    // Create time-lock puzzle with the key
    const puzzle = createTimeLockPuzzle(
      encryptionKey,
      new Date(unlockDate).getTime() / 1000,
      DIFFICULTY_MEDIUM
    );
    
    // Store on Solana
    const program = getProgram();
    
    const tx = await program.methods
      .createCapsule(
        Array.from(encrypted),
        new Date(unlockDate).getTime() / 1000,
        DIFFICULTY_MEDIUM
      )
      .accounts({
        creator: wallet.publicKey,
      })
      .rpc();
      
    console.log('Capsule created:', tx);
    
    // Store puzzle pieces (off-chain or IPFS)
    await storePuzzlePieces(puzzle);
  };
  
  return (
    <div className="create-capsule">
      <h2>Create Time Capsule</h2>
      
      <textarea
        placeholder="Your secret message..."
        value={message}
        onChange={(e) => setMessage(e.target.value)}
      />
      
      <input
        type="datetime-local"
        value={unlockDate}
        onChange={(e) => setUnlockDate(e.target.value)}
      />
      
      <button onClick={createCapsule}>
        Create Capsule
      </button>
    </div>
  );
}

export function UnlockCapsule({ capsuleId }: { capsuleId: string }) {
  const wallet = useWallet();
  const [status, setStatus] = useState<'locked' | 'solving' | 'unlocked'>('locked');
  const [progress, setProgress] = useState(0);
  const [decryptedMessage, setDecryptedMessage] = useState('');
  
  const unlockCapsule = async () => {
    setStatus('solving');
    
    // Fetch capsule data
    const program = getProgram();
    const capsule = await program.account.timeCapsule.fetch(
      new PublicKey(capsuleId)
    );
    
    // Check if time has passed
    const now = Date.now() / 1000;
    if (now < capsule.unlockTimestamp) {
      throw new Error('Too early to unlock!');
    }
    
    // Solve the puzzle (this takes time!)
    const solution = await solvePuzzle(
      capsule.puzzleDifficulty,
      capsule.createdAt,
      (prog) => setProgress(prog)
    );
    
    // Submit solution to smart contract
    await program.methods
      .revealKey(Array.from(solution))
      .accounts({
        solver: wallet.publicKey,
        capsule: new PublicKey(capsuleId),
      })
      .rpc();
      
    // Decrypt the message
    const decrypted = await decrypt(
      capsule.encryptedData,
      solution
    );
    
    setDecryptedMessage(decrypted);
    setStatus('unlocked');
  };
  
  return (
    <div className="unlock-capsule">
      {status === 'locked' && (
        <button onClick={unlockCapsule}>
          Unlock Capsule
        </button>
      )}
      
      {status === 'solving' && (
        <div className="progress">
          <p>Solving puzzle... {progress}%</p>
          <div className="progress-bar">
            <div style={{ width: `${progress}%` }} />
          </div>
        </div>
      )}
      
      {status === 'unlocked' && (
        <div className="message">
          <h3>Unlocked!</h3>
          <p>{decryptedMessage}</p>
        </div>
      )}
    </div>
  );
}

import { sha256 } from '@noble/hashes/sha256';
 
interface PuzzleParams {
  difficulty: number;
  created_at: number;
  target: Uint8Array;
}
 
async function solvePuzzle(
  difficulty: number,
  createdAt: number,
  onProgress?: (progress: number) => void
): Promise<Uint8Array> {
  const target = computeTarget(difficulty);
  let nonce = 0;
  const maxIterations = Math.pow(2, difficulty);
  
  // Sequential computation (parallelism doesn't help much)
  while (nonce < maxIterations) {
    const attempt = createAttempt(createdAt, nonce);
    const hash = sha256(attempt);
    
    if (meetsTarget(hash, target)) {
      return hash; // This is the decryption key!
    }
    
    nonce++;
    
    // Report progress
    if (onProgress && nonce % 10000 === 0) {
      const progress = (nonce / maxIterations) * 100;
      onProgress(progress);
    }
  }
  
  throw new Error('Puzzle solution not found');
}
 
function computeTarget(difficulty: number): Uint8Array {
  // Target decreases exponentially with difficulty
  const target = new Uint8Array(32);
  const leadingZeroBytes = Math.floor(difficulty / 8);
  
  // Fill with 0xFF after leading zeros
  for (let i = leadingZeroBytes; i < 32; i++) {
    target[i] = 0xFF;
  }
  
  return target;
}
 
function createAttempt(createdAt: number, nonce: number): Uint8Array {
  const buffer = new ArrayBuffer(12);
  const view = new DataView(buffer);
  
  view.setBigInt64(0, BigInt(createdAt), true);
  view.setUint32(8, nonce, true);
  
  return new Uint8Array(buffer);
}
 
function meetsTarget(hash: Uint8Array, target: Uint8Array): boolean {
  for (let i = 0; i < 32; i++) {
    if (hash[i] < target[i]) return true;
    if (hash[i] > target[i]) return false;
  }
  return true;
}

const PRESETS = {
  'future-me-1-year': {
    duration: 365 * 24 * 60 * 60, // 1 year in seconds
    title: 'Message to Future Me (1 Year)',
    prompt: 'What do you want to tell yourself in a year?',
  },
  'birthday-surprise': {
    duration: null, // User picks date
    title: 'Birthday Surprise',
    prompt: 'Write a birthday message to be revealed on their special day',
  },
  'time-capsule-5-years': {
    duration: 5 * 365 * 24 * 60 * 60,
    title: 'Time Capsule (5 Years)',
    prompt: 'What do you want to preserve for 5 years from now?',
  },
};
 
function PresetSelector({ onSelect }: { onSelect: (preset: string) => void }) {
  return (
    <div className="presets">
      <h3>Quick Start</h3>
      {Object.entries(PRESETS).map(([key, preset]) => (
        <button key={key} onClick={() => onSelect(key)}>
          {preset.title}
        </button>
      ))}
    </div>
  );
}

function UnlockProgress({ capsule }: { capsule: TimeCapsule }) {
  const timeUntilUnlock = capsule.unlockTimestamp * 1000 - Date.now();
  
  if (timeUntilUnlock > 0) {
    return (
      <div className="locked">
        <LockIcon />
        <h3>Capsule Locked</h3>
        <Countdown target={capsule.unlockTimestamp * 1000} />
        <p>Come back on {new Date(capsule.unlockTimestamp * 1000).toLocaleDateString()}</p>
      </div>
    );
  }
  
  if (!capsule.isUnlocked) {
    return (
      <div className="ready-to-unlock">
        <UnlockIcon />
        <h3>Ready to Unlock!</h3>
        <p>Solve the puzzle to reveal your message</p>
        <button onClick={() => startUnlock(capsule)}>
          Begin Unlock
        </button>
      </div>
    );
  }
  
  return (
    <div className="unlocked">
      <CheckIcon />
      <h3>Unlocked!</h3>
      <p>Your message is ready</p>
    </div>
  );
}

// puzzle-worker.ts
self.onmessage = async (e) => {
  const { difficulty, createdAt } = e.data;
  
  const solution = await solvePuzzle(difficulty, createdAt, (progress) => {
    self.postMessage({ type: 'progress', progress });
  });
  
  self.postMessage({ type: 'complete', solution });
};
 
// main.ts
const worker = new Worker('puzzle-worker.ts');
 
worker.onmessage = (e) => {
  if (e.data.type === 'progress') {
    updateProgress(e.data.progress);
  } else if (e.data.type === 'complete') {
    handleSolution(e.data.solution);
  }
};
 
worker.postMessage({ difficulty, createdAt });