from flask import Flask, render_template, request, jsonify, send_file, session
from datetime import datetime, timedelta
import requests
import json
import os
import time
import base64
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
import qrcode
import io
import base58
import hashlib
import secrets

app = Flask(__name__)
app.secret_key = secrets.token_hex(32)

# Storage files
WALLET_FILE = 'wallets.json'
PRIVILEGE_FILE = 'privilege_log.json'

# Initialize storage files
def init_storage():
    if not os.path.exists(WALLET_FILE):
        with open(WALLET_FILE, 'w') as f:
            json.dump({}, f)
    
    if not os.path.exists(PRIVILEGE_FILE):
        with open(PRIVILEGE_FILE, 'w') as f:
            json.dump({}, f)

class NanoWallet:
    """Simple Nano-like wallet implementation"""
    
    def __init__(self):
        self.wallets = self.load_wallets()
    
    def load_wallets(self):
        try:
            with open(WALLET_FILE, 'r') as f:
                return json.load(f)
        except:
            return {}
    
    def save_wallets(self):
        with open(WALLET_FILE, 'w') as f:
            json.dump(self.wallets, f)
    
    def generate_wallet(self, user_id):
        """Generate a simple wallet address"""
        # Generate a unique address
        timestamp = str(time.time())
        random_bytes = secrets.token_bytes(16)
        address_data = f"{user_id}{timestamp}".encode() + random_bytes
        address = base58.b58encode(hashlib.sha256(address_data).digest()[:20]).decode()
        
        # Generate a simple "private key" (for demo purposes)
        private_key = secrets.token_hex(32)
        
        wallet_data = {
            'address': address,
            'private_key': private_key,  # In real implementation, encrypt this!
            'balance': '0.000000',
            'last_update': time.time()
        }
        
        self.wallets[user_id] = wallet_data
        self.save_wallets()
        
        return wallet_data
    
    def get_wallet(self, user_id):
        if user_id not in self.wallets:
            return self.generate_wallet(user_id)
        return self.wallets[user_id]
    
    def update_balance(self, user_id):
        """Simulate balance updates every 15 seconds"""
        if user_id in self.wallets:
            # Generate a small random amount
            import random
            increase = random.uniform(0.000001, 0.00001)
            current = float(self.wallets[user_id]['balance'])
            self.wallets[user_id]['balance'] = f"{current + increase:.6f}"
            self.wallets[user_id]['last_update'] = time.time()
            self.save_wallets()

class PrivilegeSystem:
    def __init__(self):
        self.privilege_log = self.load_privilege_log()
    
    def load_privilege_log(self):
        try:
            with open(PRIVILEGE_FILE, 'r') as f:
                return json.load(f)
        except:
            return {}
    
    def save_privilege_log(self):
        with open(PRIVILEGE_FILE, 'w') as f:
            json.dump(self.privilege_log, f)
    
    def can_grab_privilege(self, user_id, privilege_type):
        """Check if user can grab privilege (4-hour cooldown)"""
        user_key = f"{user_id}_{privilege_type}"
        
        if user_key not in self.privilege_log:
            return True, 0
        
        last_grab = self.privilege_log[user_key]
        current_time = time.time()
        cooldown = 4 * 3600  # 4 hours in seconds
        
        time_since_last = current_time - last_grab
        time_remaining = max(0, cooldown - time_since_last)
        
        return time_since_last >= cooldown, time_remaining
    
    def grab_privilege(self, user_id, privilege_type):
        """Register privilege grab"""
        user_key = f"{user_id}_{privilege_type}"
        self.privilege_log[user_key] = time.time()
        self.save_privilege_log()
        
        # Register with external service
        try:
            response = requests.get(
                'https://1hit.no/priv/default.php',
                params={
                    'user': user_id,
                    'type': privilege_type,
                    'time': int(time.time())
                },
                timeout=5
            )
            print(f"Registered with external service: {response.status_code}")
        except Exception as e:
            print(f"External registration failed: {e}")
        
        return True

# Initialize systems
init_storage()
wallet_system = NanoWallet()
privilege_system = PrivilegeSystem()

@app.route('/')
def index():
    # Generate or get user ID from session
    if 'user_id' not in session:
        session['user_id'] = secrets.token_hex(8)
    
    user_id = session['user_id']
    wallet = wallet_system.get_wallet(user_id)
    
    return render_template('index.html', 
                         wallet=wallet,
                         user_id=user_id)

@app.route('/get_wallet')
def get_wallet():
    user_id = session.get('user_id', secrets.token_hex(8))
    wallet = wallet_system.get_wallet(user_id)
    
    # Update balance for display
    wallet_system.update_balance(user_id)
    
    return jsonify(wallet)

@app.route('/download_wallet')
def download_wallet():
    user_id = session.get('user_id')
    if not user_id:
        return "No wallet found", 404
    
    wallet = wallet_system.get_wallet(user_id)
    
    # Create wallet data file
    wallet_data = f"""=== WEIRD PRIVILEGE SPACE WALLET ===
User ID: {user_id}
Wallet Address: {wallet['address']}
Private Key: {wallet['private_key']}
Balance: {wallet['balance']} NANO
Last Updated: {datetime.fromtimestamp(wallet['last_update']).isoformat()}

=== WARNING ===
Keep this file secure! This is your digital identity.
"""
    
    # Return as downloadable file
    return send_file(
        io.BytesIO(wallet_data.encode()),
        as_attachment=True,
        download_name=f'wallet_{user_id}.txt',
        mimetype='text/plain'
    )

@app.route('/check_privilege/<privilege_type>')
def check_privilege(privilege_type):
    user_id = session.get('user_id')
    if not user_id:
        return jsonify({'error': 'No user session'}), 401
    
    can_grab, time_remaining = privilege_system.can_grab_privilege(user_id, privilege_type)
    
    return jsonify({
        'can_grab': can_grab,
        'time_remaining': time_remaining,
        'cooldown_hours': 4
    })

@app.route('/grab_privilege/<privilege_type>')
def grab_privilege(privilege_type):
    user_id = session.get('user_id')
    if not user_id:
        return jsonify({'error': 'No user session'}), 401
    
    can_grab, time_remaining = privilege_system.can_grab_privilege(user_id, privilege_type)
    
    if not can_grab:
        return jsonify({
            'success': False,
            'error': f'Privilege cooldown active. Wait {time_remaining:.0f} seconds.'
        })
    
    # Grab the privilege
    privilege_system.grab_privilege(user_id, privilege_type)
    
    return jsonify({
        'success': True,
        'message': f'Grabbed {privilege_type} privilege!',
        'simulation': 'You have simulated privilege now.'
    })

@app.route('/simulate_privilege')
def simulate_privilege():
    return jsonify({
        'message': 'YOU HAVE SIMULATED PRIVILEGE NOW',
        'timestamp': datetime.now().isoformat()
    })

@app.route('/qr_code/<address>')
def generate_qr(address):
    # Generate QR code for wallet address
    qr = qrcode.make(address)
    img_io = io.BytesIO()
    qr.save(img_io, 'PNG')
    img_io.seek(0)
    
    return send_file(img_io, mimetype='image/png')

if __name__ == '__main__':
    app.run(debug=True, port=5000)