import tensorflow as tf
from tensorflow.keras import layers, models

# Build a simple CNN for card authenticity detection
def create_card_scanner_model():
    model = models.Sequential([
        # Input layer: Card image (224x224 RGB)
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)),
        layers.MaxPooling2D((2, 2)),
        
        # Hidden layers: Extract features
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        
        layers.Conv2D(128, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        
        # Flatten and classify
        layers.Flatten(),
        layers.Dense(128, activation='relu'),
        layers.Dropout(0.5),
        
        # Output: Real (1) or Fake (0)
        layers.Dense(1, activation='sigmoid')
    ])
    
    model.compile(
        optimizer='adam',
        loss='binary_crossentropy',
        metrics=['accuracy']
    )
    
    return model

# Train the model
model = create_card_scanner_model()
# model.fit(training_data, training_labels, epochs=50)

# Predict authenticity
def scan_card(image):
    prediction = model.predict(image)
    return "Real Card! ✅" if prediction > 0.5 else "Fake Card! ⚠️"

import numpy as np
from PIL import Image
import hashlib

def analyze_pixel_block(image_array, x, y, block_size=64):
    """
    Analyze a pixel block and compute density and flaw scores.
    
    Args:
        image_array: NumPy array of the card image
        x, y: Block position coordinates
        block_size: Size of each block in pixels
    
    Returns:
        Dictionary with block analysis data
    """
    # Extract the pixel block
    block = image_array[
        y*block_size:(y+1)*block_size,
        x*block_size:(x+1)*block_size
    ]
    
    # Compute color histogram (RGB channels)
    hist_r = np.histogram(block[:,:,0], bins=256)[0]
    hist_g = np.histogram(block[:,:,1], bins=256)[0]
    hist_b = np.histogram(block[:,:,2], bins=256)[0]
    
    # Calculate density score (high-intensity pixel count)
    density_score = np.sum(block > 200) / block.size
    
    # Detect flaws (sudden color changes, scratches)
    edges = np.abs(np.diff(block.astype(float), axis=0))
    flaw_score = np.sum(edges > 50) / edges.size
    
    return {
        'position': (x, y),
        'color_histogram': {
            'r': hist_r.tolist(),
            'g': hist_g.tolist(),
            'b': hist_b.tolist()
        },
        'density_score': float(density_score),
        'flaw_score': float(flaw_score)
    }

def create_card_codex(image_path, grid_size=4):
    """
    Create a complete codex for a card image.
    
    Args:
        image_path: Path to the card image
        grid_size: Number of blocks per dimension
    
    Returns:
        Complete codex dictionary
    """
    # Load and prepare image
    img = Image.open(image_path).convert('RGB')
    img_array = np.array(img)
    
    # Analyze all blocks
    blocks = []
    total_density = 0
    total_flaw = 0
    
    for y in range(grid_size):
        for x in range(grid_size):
            block_data = analyze_pixel_block(img_array, x, y)
            blocks.append(block_data)
            total_density += block_data['density_score']
            total_flaw += block_data['flaw_score']
    
    # Generate unique hash
    codex_string = f"{image_path}{total_density}{total_flaw}"
    codex_hash = hashlib.sha256(codex_string.encode()).hexdigest()
    
    return {
        'card_id': 'BABE_RUTH_GENESIS_1914',
        'codex_hash': codex_hash,
        'encoded_blocks': blocks,
        'overall_density': total_density,
        'total_flaw_score': total_flaw,
        'ai_grade': max(1, min(10, 10 - (total_flaw * 100)))
    }

# Example usage
codex = create_card_codex('babe_ruth_genesis.jpg')
print(f"Codex Hash: {codex['codex_hash']}")
print(f"AI Grade: {codex['ai_grade']:.1f}/10")

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract CardForgeNFT is ERC721, Ownable {
    uint256 private _tokenIdCounter;
    
    struct CardData {
        string cardName;
        string cardSet;
        uint8 grade;           // 1-10 condition grade
        bool isAuthentic;      // AI verification result
        uint256 mintTimestamp;
        string imageURI;
        bytes32 codexHash;     // Mathematical encoding fingerprint
    }
    
    mapping(uint256 => CardData) public cardRegistry;
    
    event CardMinted(
        uint256 indexed tokenId,
        address indexed owner,
        string cardName,
        uint8 grade,
        bytes32 codexHash
    );
    
    constructor() ERC721("CardForge", "CARD") Ownable(msg.sender) {}
    
    function mintCard(
        address to,
        string memory cardName,
        string memory cardSet,
        uint8 grade,
        bool isAuthentic,
        string memory imageURI,
        bytes32 codexHash
    ) public onlyOwner returns (uint256) {
        require(grade >= 1 && grade <= 10, "Grade must be 1-10");
        require(isAuthentic, "Only authentic cards can be minted");
        
        uint256 tokenId = _tokenIdCounter;
        _tokenIdCounter++;
        
        _safeMint(to, tokenId);
        
        cardRegistry[tokenId] = CardData({
            cardName: cardName,
            cardSet: cardSet,
            grade: grade,
            isAuthentic: isAuthentic,
            mintTimestamp: block.timestamp,
            imageURI: imageURI,
            codexHash: codexHash
        });
        
        emit CardMinted(tokenId, to, cardName, grade, codexHash);
        
        return tokenId;
    }
    
    function getCardData(uint256 tokenId) public view returns (CardData memory) {
        require(ownerOf(tokenId) != address(0), "Card does not exist");
        return cardRegistry[tokenId];
    }
    
    function verifyCodex(uint256 tokenId, bytes32 codexHash) public view returns (bool) {
        return cardRegistry[tokenId].codexHash == codexHash;
    }
}

import { useState } from 'react';
import Web3 from 'web3';
import { Button } from '@/components/ui/button';

// Connect to blockchain and mint NFT
export function CardScanner() {
  const [scanning, setScanning] = useState(false);
  const [result, setResult] = useState<string>('');

  const scanAndMintCard = async (imageFile: File) => {
    setScanning(true);
    
    try {
      // Step 1: AI scans the card
      const formData = new FormData();
      formData.append('image', imageFile);
      
      const aiResponse = await fetch('/api/scan-card', {
        method: 'POST',
        body: formData,
      });
      
      const { isAuthentic, grade, cardName, cardSet } = await aiResponse.json();
      
      if (!isAuthentic) {
        setResult('⚠️ Fake card detected! Cannot mint NFT.');
        return;
      }
      
      // Step 2: Generate mathematical codex
      const codexResponse = await fetch('/api/generate-codex', {
        method: 'POST',
        body: formData,
      });
      const { codexHash, encodedBlocks } = await codexResponse.json();
      
      // Step 3: Upload image to IPFS
      const ipfsResponse = await fetch('/api/upload-to-ipfs', {
        method: 'POST',
        body: formData,
      });
      const { imageURI } = await ipfsResponse.json();
      
      // Step 4: Mint NFT on blockchain
      const web3 = new Web3(window.ethereum);
      await window.ethereum.request({ method: 'eth_requestAccounts' });
      
      const contract = new web3.eth.Contract(
        CardForgeABI,
        CONTRACT_ADDRESS
      );
      
      const accounts = await web3.eth.getAccounts();
      
      const tx = await contract.methods
        .mintCard(
          accounts[0],
          cardName,
          cardSet,
          grade,
          isAuthentic,
          imageURI,
          codexHash
        )
        .send({ from: accounts[0] });
      
      setResult(`✅ Success! NFT minted. Token ID: ${tx.events.CardMinted.returnValues.tokenId}`);
      
    } catch (error) {
      setResult(`❌ Error: ${error.message}`);
    } finally {
      setScanning(false);
    }
  };

  return (
    <div className="space-y-4">
      <input
        type="file"
        accept="image/*"
        onChange={(e) => {
          if (e.target.files?.[0]) {
            scanAndMintCard(e.target.files[0]);
          }
        }}
        disabled={scanning}
      />
      <Button disabled={scanning}>
        {scanning ? 'Scanning...' : 'Scan Card'}
      </Button>
      {result && <p className="text-sm">{result}</p>}
    </div>
  );
}

import { useState } from 'react';
import { cn } from '@/lib/utils';

export function FlipCard({ frontImage, backImage, cardName }: FlipCardProps) {
  const [isFlipped, setIsFlipped] = useState(false);

  return (
    <div
      className="relative w-64 h-96 cursor-pointer perspective-1000"
      onClick={() => setIsFlipped(!isFlipped)}
    >
      <div
        className={cn(
          "relative w-full h-full transition-transform duration-700 transform-style-3d",
          isFlipped && "rotate-y-180"
        )}
      >
        {/* Front of card */}
        <div className="absolute w-full h-full backface-hidden">
          <div className="w-full h-full rounded-xl shadow-2xl overflow-hidden border-4 border-primary/50">
            <img
              src={frontImage}
              alt={cardName}
              className="w-full h-full object-cover"
            />
          </div>
        </div>
        
        {/* Back of card */}
        <div className="absolute w-full h-full backface-hidden rotate-y-180">
          <div className="w-full h-full rounded-xl shadow-2xl overflow-hidden border-4 border-chart-2/50 bg-gradient-to-br from-chart-1 to-chart-2 flex items-center justify-center">
            <img
              src={backImage}
              alt="Card back"
              className="w-full h-full object-cover"
            />
          </div>
        </div>
      </div>
    </div>
  );
}

// Add to tailwind.config.js:
// theme: {
//   extend: {
//     perspective: {
//       '1000': '1000px',
//     },
//     transformStyle: {
//       '3d': 'preserve-3d',
//     },
//     backfaceVisibility: {
//       'hidden': 'hidden',
//     },
//     rotate: {
//       'y-180': 'rotateY(180deg)',
//     },
//   },
// },