import cu from './web/cu-api.js';

await cu.load();
cu.init();

// Basic usage
const result = await cu.compute('return "Hello from Lua!"');
console.log(result); // "Hello from Lua!"

// Store data in _home table (with automatic persistence)
await cu.compute(`
    _home.users = _home.users or {}
    _home.users.user1 = { name = 'Alice', age = 30 }
    _home.users.user2 = { name = 'Bob', age = 25 }
`);

// Data persists automatically - save to IndexedDB
await cu.saveState();

// After page refresh, data is automatically restored

// BigInt module for arbitrary-precision arithmetic
await cu.compute(`
    local bigint = require('bigint')
    
    -- Ethereum wei calculations (18 decimals)
    local eth = bigint.new("1000000000000000000")  -- 1 ETH in wei
    local gas = bigint.new("21000")                -- Standard transfer gas
    local gwei = bigint.new("50")                  -- Gas price in gwei
    local wei_per_gwei = bigint.new("1000000000")
    
    local gas_price_wei = gwei * wei_per_gwei
    local total_fee = gas * gas_price_wei
    local remaining = eth - total_fee
    
    _io.output = {
        original = tostring(eth),
        fee = tostring(total_fee),
        remaining = tostring(remaining)
    }
`);

const result = cu.getOutput();
console.log('Remaining:', result.remaining, 'wei');
// Remaining: 998950000000000000 wei

// Operator overloading and comparisons
await cu.compute(`
    local bigint = require('bigint')
    local a = bigint.new("999999999999999999999999999999")
    local b = bigint.new("1")
    local sum = a + b  -- Works seamlessly with + - * / % operators
    
    print("Sum: " .. tostring(sum))
    print("Greater than original: " .. tostring(sum > a))
`);

import cu from './lua-api.js';

// Initialize
await cu.load();
cu.init();

// Process structured data with setInput/getOutput
cu.setInput({
  users: [
    { id: 1, name: "Alice", score: 95 },
    { id: 2, name: "Bob", score: 87 },
    { id: 3, name: "Charlie", score: 92 }
  ],
  threshold: 90
});

cu.compute(`
  local users = _io.input.users
  local threshold = _io.input.threshold
  
  local highScorers = {}
  for i, user in ipairs(users) do
    if user.score >= threshold then
      table.insert(highScorers, {
        name = user.name,
        score = user.score
      })
    end
  end
  
  _io.output = {
    highScorers = highScorers,
    count = #highScorers
  }
`);

const result = cu.getOutput();
console.log(result);
// {
//   highScorers: [
//     { name: "Alice", score: 95 },
//     { name: "Charlie", score: 92 }
//   ],
//   count: 2
// }

import { IoWrapper } from './io-wrapper.js';

const io = new IoWrapper();

// Simple request/response pattern
const result = await io.computeWithIo(`
  local data = _io.input.dataset
  local sum = 0
  for i, v in ipairs(data) do
    sum = sum + v
  end
  _io.output = { sum = sum, average = sum / #data }
`, {
  dataset: [10, 20, 30, 40, 50]
});

console.log(result.output); // { sum: 150, average: 30 }

// Stream processing for very large datasets
const largeDataset = new Array(100000).fill(0).map((_, i) => ({
  id: i,
  value: Math.random() * 100
}));

const results = await io.processStream(`
  local batch = _io.input.batch
  local processed = {}
  for i, item in ipairs(batch) do
    processed[i] = {
      id = item.id,
      doubled = item.value * 2
    }
  end
  _io.output = processed
`, largeDataset, { batchSize: 1000 });

// Define functions in _home table
await cu.compute(`
    function _home.taxCalculator(income, deductions) 
        local taxable = income - (deductions or 0)
        local brackets = {10000, 50000, 100000}
        local rates = {0.1, 0.2, 0.3, 0.4}
        -- Complex tax calculation logic
        return taxable * rates[1]  -- Simplified
    end
`);

// Function with closures
await cu.compute(`
    local count = 0
    function _home.counterFactory()
        count = count + 1
        return count
    end
`);

// Save functions to persist across page reloads
await cu.saveState();

// Use functions (they persist automatically after reload)
const result = await cu.compute(`
    return {
        tax = _home.taxCalculator(75000, 5000),
        count1 = _home.counterFactory(),
        count2 = _home.counterFactory()
    }
`);
console.log(result);

// Store bulk data using Lua tables
const users = Array.from({length: 1000}, (_, i) => ({
    id: i,
    name: `User ${i}`,
    email: `user${i}@example.com`,
    score: Math.floor(Math.random() * 1000)
}));

// Insert users via Lua
console.time('Insert 1000 users');
await cu.compute(`
    _home.appUsers = _home.appUsers or {}
    -- Users will be populated via JavaScript calls
`);

// Build Lua code to insert all users
let insertCode = '_home.appUsers = _home.appUsers or {}\n';
users.forEach(user => {
    insertCode += `_home.appUsers.user_${user.id} = {
        id = ${user.id},
        name = "${user.name}",
        email = "${user.email}",
        score = ${user.score}
    }\n`;
});

await cu.compute(insertCode);
console.timeEnd('Insert 1000 users');

// Save all data
await cu.saveState();

// Query data using Lua directly
const highScorers = await cu.compute(`
    local results = {}
    for key, user in pairs(_home.appUsers) do
        if user.score >= 800 then
            table.insert(results, user)
        end
    end
    table.sort(results, function(a, b) return a.score > b.score end)
    return results
`);

console.log('Top scorers:', highScorers);

// Range queries
const midRangeUsers = await cu.compute(`
    local results = {}
    for key, user in pairs(_home.appUsers) do
        if user.score >= 400 and user.score <= 600 then
            table.insert(results, user)
        end
    end
    return results
`);

// String matching
const emailResults = await cu.compute(`
    local results = {}
    for key, user in pairs(_home.appUsers) do
        if string.match(user.email, "example") then
            table.insert(results, user)
        end
    end
    return results
`);

// Define analytical functions
await cu.compute(`
    function _home.average(values)
        local sum = 0
        for _, v in ipairs(values) do sum = sum + v end
        return sum / #values
    end
    
    function _home.median(values)
        table.sort(values)
        local n = #values
        if n % 2 == 0 then
            return (values[n/2] + values[n/2 + 1]) / 2
        else
            return values[(n + 1) / 2]
        end
    end
    
    function _home.stdev(values)
        local avg = _home.average(values)
        local sum = 0
        for _, v in ipairs(values) do
            sum = sum + (v - avg)^2
        end
        return math.sqrt(sum / #values)
    end
`);

// Use analytical functions
const analysis = await cu.compute(`
    local scores = {}
    for i = 1, 100 do
        scores[i] = math.random(100, 1000)
    end
    
    return {
        average = _home.average(scores),
        median = _home.median(scores),
        stdev = _home.stdev(scores),
        min = math.min(unpack(scores)),
        max = math.max(unpack(scores))
    }
`);

console.log('Score analysis:', analysis);

// Save analysis functions for reuse
await cu.saveState();

cu.setInput({
  users: [{ id: 1, name: "Alice" }],
  config: { limit: 100 }
});

cu.compute(`
  local users = _io.input.users
  local limit = _io.input.config.limit
  -- Process data
`);

cu.compute(`
  _io.output = {
    result = "success",
    items = {1, 2, 3}
  }
`);

const output = cu.getOutput();
console.log(output); // { result: "success", items: [1, 2, 3] }

lua.setMetadata({
  requestId: 'req-123',
  timestamp: Date.now()
});

lua.clearIo(); // Reset _io state between requests

import { IoWrapper } from './io-wrapper.js';
const io = new IoWrapper();

const result = await io.computeWithIo(`
  local sum = 0
  for i, v in ipairs(_io.input.numbers) do
    sum = sum + v
  end
  _io.output = { sum = sum }
`, { numbers: [1, 2, 3, 4, 5] });

console.log(result.output.sum); // 15

const results = await io.processStream(`
  local batch = _io.input.batch
  local processed = {}
  for i, item in ipairs(batch) do
    processed[i] = item.value * 2
  end
  _io.output = processed
`, largeDataset, { batchSize: 1000 });

// Define handler in Lua
await cu.compute(`
  function calculateStats(params)
    local sum = 0
    for _, v in ipairs(params.data) do
      sum = sum + v
    end
    return { sum = sum }
  end
`);

// Call via request
const result = await io.request('calculateStats', {
  data: [1, 2, 3, 4, 5]
});

// Direct table access
const user = await cu.compute('return _home.users.user1');

// Iteration over tables
const userCount = await cu.compute(`
    local count = 0
    for key, user in pairs(_home.users) do
        count = count + 1
    end
    return count
`);

// Filtering and mapping
const results = await cu.compute(`
    local active = {}
    for key, user in pairs(_home.users) do
        if user.status == "active" then
            table.insert(active, user)
        end
    end
    return active
`);

// Function serialization performance
console.time('Function Persistence');
await cu.compute(`
    function _home.testFunc(x) 
        return x * 2 
    end
`);
await cu.saveState();
console.timeEnd('Function Persistence'); // ~2-10ms

// Bulk data storage
console.time('Store 1000 items');
let code = '_home.bench = {}\n';
for (let i = 0; i < 1000; i++) {
    code += `_home.bench.key${i} = "value${i}"\n`;
}
await cu.compute(code);
console.timeEnd('Store 1000 items'); // ~50-100ms

// Table iteration performance
console.time('Query 1000 items');
const results = await cu.compute(`
    local results = {}
    for key, value in pairs(_home.bench) do
        if string.match(key, "key5") then
            table.insert(results, {key = key, value = value})
        end
    end
    return results
`);
console.timeEnd('Query 1000 items'); // ~5-20ms

// Always wrap code in try-catch for error handling
try {
    const result = await cu.compute(`
        return _home.getValue("key")
    `);
} catch (error) {
    console.error('Lua execution error:', error);
}

// Save state regularly to persist data
setInterval(async () => {
    await cu.saveState();
    console.log('State saved');
}, 5000);

// Use consistent naming for _home table keys
await cu.compute(`
    _home.config = _home.config or {}
    _home.data = _home.data or {}
    _home.cache = _home.cache or {}
`);

// Monitor memory usage
const stats = lua.getMemoryStats();
console.log('Memory used:', stats.used, 'bytes');