module.exports = (fs, express, addFunction, functionMatch, addWsFunction, get, set, update, remove, query, generateRequestId, data, addDomain, startDB, onConnection, onClose) => {
 
  // Server configuration goes here

}

const productionDomain = addDomain({
  domain: "example.com",
  https: {
    key: '/etc/letsencrypt/live/example.com/privkey.pem',
    cert: '/etc/letsencrypt/live/example.com/fullchain.pem'
  }
});

// You can add as many domains as needed
const anotherDomain = addDomain({
  domain: "another-domain.com",
  https: {
    key: '/etc/letsencrypt/live/another-domain.com/privkey.pem',
    cert: '/etc/letsencrypt/live/another-domain.com/fullchain.pem'
  }
});

const devDomain = addDomain({
  domain: "exampledomain.com",
  https: {
    key: '',
    cert: ''
  }
});

// Serve static files
myDomain.app.use(express.static(path.join(process.cwd(), `../public`)));

// Serve files with long cache time
myDomain.app.use('/files', express.static(path.join(process.cwd(), `../files`), { 
    maxAge: 60 * 60 * 24 * 1000 * 365  // 1 year in milliseconds
}));

// Create a trigger for when a request is updated
addFunction("onUpdate", "requests.$requestId", async function(context) {
  // The context object contains all relevant information about the change
  const beforeNotes = context.dataBefore?.notes;
  const afterNotes = context.dataAfter?.notes;
  // Replace "pizza" with pizza emoji
  const newNotes = afterNotes.replaceAll("pizza", "🍕");
  // Avoid infinite loop by checking if we already replaced
  if (newNotes === afterNotes) {
    return;
  }
  // Update the data with our modified version
  update(context.path, { notes: newNotes });
});

// React to new orders being created
addFunction("onSet", "orders.$orderId", async function(context) {
  // Only run if this is a new order (no previous data)
  if (!context.dataBefore && context.dataAfter) {
    // Extract orderId from the path
    const orderId = context.path.split('.')[1];
      // Update the order status
    await update(context.path, {
      status: "processing",
      processingStart: Date.now()
    });
  }
});

addWsFunction("addNumbers", function (data, admin, sessionId, userId) {
    // Extract numbers from the request
    const { num1, num2 } = data;
    
    // Perform the calculation on the server
    const sum = num1 + num2;
    
    // Return the result to the client
    return sum;
});

// When a client connects
onConnection(function (userId, sessionId) {
    // Record session start time
    update(`sessions.${userId}.${sessionId}`, { 
        start: Date.now()
    });
});

// When a client disconnects
onClose(function (userId, sessionId) {
    // Record session end time
    update(`sessions.${userId}.${sessionId}`, { 
        end: Date.now() 
    });
});

// Local IP Address mode (no SSL) 
startDB({ local: true, http: "127.0.0.1", port: 3000 });

// Server IP Address mode (no SSL) 
startDB({ local: true, http: "126.23.45.1", port: 3000 });

// Production mode (with SSL)
startDB({ local: false, http: "0.0.0.0", port: 3000 });

module.exports = (fs, express, addFunction, addWsFunction, get, set, update, remove, query, generateRequestId, data, addDomain, startDB, onConnection, onClose) => {

// Set up a domain
const myApp = addDomain({
domain: "myapp.com",
  https: {
  key: '/etc/letsencrypt/live/myapp.com/privkey.pem',
  cert: '/etc/letsencrypt/live/myapp.com/fullchain.pem'
}
});
// Configure middleware for serving static files
const path = require('path');
myApp.app.use(express.static(path.join(process.cwd(), 'public')));

// Add a database trigger for important changes
addFunction("onValue", "orders.$orderId", async function(context) {
  // Only trigger if data has actually changed
  if (JSON.stringify(context.dataAfter) !== JSON.stringify(context.dataBefore)) {
    await set(logs.${generateRequestId()}, {
      path: context.path,
      timestamp: Date.now(),
      oldValue: context.dataBefore,
      newValue: context.dataAfter,
      change: "Important data changed"
    });
  }
});

// Add a WebSocket function for client calculations
addWsFunction("addNumbers", function(data, admin, sessionId, userId) {
  // Extract numbers from the request
  const { num1, num2 } = data;
  // Perform the calculation on the server
  const sum = num1 + num2;
  // Return the result to the client
  return sum;
});

// Track user connections
onConnection(function(userId, sessionId) {
  // Record when user connects
  update(sessions.${userId}.${sessionId}, {
    start: Date.now(),
    userAgent: data.request?.headers?.["user-agent"] || "Unknown"
  });

  // Update user status
  update(`users.${userId}`, { 
    online: true,
    lastSeen: Date.now()
  });
});

// Handle user disconnections
onClose(function(userId, sessionId) {
  // Record when user disconnects
  update(sessions.${userId}.${sessionId}, {
    end: Date.now(),
    duration: function(current) {
    return current.end - current.start;
  }
  });

  // Update user status
  update(`users.${userId}`, { 
    online: false,
    lastSeen: Date.now()
  });
});

// Start the server (local mode on port 3000)
startDB({ local: true, http: "127.0.0.1", port: 3000 });
console.log(🚀 NukeBase server running on Node.js "http://127.0.0.1:3000");
};

const urlParam = new URLSearchParams(location.search);

function generateRequestId() {
    const chars = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZ';
    let result = '';
    for (let i = 0; i < 8; i++) {
        result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
}

function sendRequest(action, path, socket, data) {
    return new Promise((resolve, reject) => {
        admin = urlParam.get("admin") || "";
        const requestId = generateRequestId();
        pendingRequests[requestId] = { resolve, reject };
        socket.send(JSON.stringify({ action, path, requestId, data, admin }));
    });
}


function sendSubscribe(action, path, socket, data) {
    admin = urlParam.get("admin") || "";
    socket.send(JSON.stringify({ action, path, data, admin }));
}

const sub = {
    events: {},
    on(action, path, callback, data) {
        this.events[action + path] = callback;
        sendSubscribe(action, path, socket, data);
    },
    emit(action, path, data) {
        if (this.events[action + path]) {
            this.events[action + path](data);
        }
    },
    off(action, path, callback, data) {
        sendSubscribe(action + 'Stop', path, socket, data)
        delete this.events[action + path];
    }
};

var pendingRequests = {};
var socket;

function connectWebSocket() {
    return new Promise((resolve, reject) => {
        const wsProtocol = window.location.protocol === "https:" ? "wss://" : "ws://";
        socket = new WebSocket(`${wsProtocol}${window.location.host}`);

        socket.addEventListener('message', function (event) {
            try {
                const response = JSON.parse(event.data);
                if (response.requestId) {
                    pendingRequests[response.requestId].resolve(response);
                    delete pendingRequests[response.requestId];
                } else {
                    sub.emit(response.action, response.path, response);
                }
            } catch (error) {
                console.error('Error parsing message:', error);
            }
        });

        socket.addEventListener('open', async () => {
            console.log('WebSocket connection opened');
            resolve();
        });

        socket.addEventListener('close', () => {
            console.log('WebSocket connection closed');
        });

        socket.addEventListener('error', (error) => {
            console.error('WebSocket error:', error);
        });
    });
}

//Reconnect WebSocket when the browser window gains focus
document.addEventListener('visibilitychange', () => {
    if (document.visibilityState === 'visible') {
        setTimeout(function () {
            if (socket.readyState === WebSocket.CLOSED) {
                connectWebSocket();
            }
        }, 500);
    }
});

function set(path, data) {
    return sendRequest("set", path, socket, data).then(data => {
        return data;
    })
}

function get(path) {
    return sendRequest('get', path, socket).then(data => {
        return data;
    })
}

function update(path, data) {
    return sendRequest("update", path, socket, data).then(data => {
        return data;
    })
}

function remove(path) {
    return sendRequest("remove", path, socket).then(data => {
        return data;
    })
}

function query(path, query) {
    return sendRequest('query', path, socket, query).then(data => {
        return data;
    })
}

function wsFunction(name, data) {
    return sendRequest(name, null, socket, data).then(data => {
        return data;
    })
}

function getSub(path, handler) {
    sub.on("getSub", path, handler);
    return function () {
        sub.off('getSub', path);
    };
}

function querySub(path, query, handler) {
    sub.on("querySub", path, handler, query);
    return function () {
        sub.off("querySub", path, handler, query);
    }
}

function getSubChanged(path, handler) {
    sub.on("getSubChanged", path, handler);
    return function () {
        sub.off('getSubChanged', path);
    };
}

function querySubChanged(path, query, handler) {
    sub.on("querySubChanged", path, handler, query);
    return function () {
        sub.off("querySubChanged", path, handler, query);
    }
}

function setFile(path, file) {
    return new Promise((resolve, reject) => {
        const requestId = generateRequestId();
        pendingRequests[requestId] = { resolve, reject };
        const separator = "--myUniqueSeparator--";
        const reader = new FileReader();
        reader.onload = function (e) {
            const arrayBuffer = e.target.result;
            const textEncoder = new TextEncoder();

            const encodedPath = textEncoder.encode(path + separator);
            const encodedFileName = textEncoder.encode(file.name + separator);
            const encodedRequestId = textEncoder.encode(requestId + separator);
            const combinedArrayBuffer = new Uint8Array(
                encodedPath.length + encodedFileName.length + encodedRequestId.length + arrayBuffer.byteLength
            );

            combinedArrayBuffer.set(encodedPath, 0);
            combinedArrayBuffer.set(encodedFileName, encodedPath.length);
            combinedArrayBuffer.set(encodedRequestId, encodedPath.length + encodedFileName.length);
            combinedArrayBuffer.set(
                new Uint8Array(arrayBuffer), encodedPath.length + encodedFileName.length + encodedRequestId.length
            );
            socket.send(combinedArrayBuffer.buffer);
        };
        reader.readAsArrayBuffer(file);
    });
}

connectWebSocket().then(() => {
    // Example usage
    set("users.matt.color", "red").then(data => {
        console.log(data);
    })

    get("sessions").then(data => {
        console.log(data);
    })

    update("users.matt", { leadsSent: "Pending" }).then(data => {
        console.log(data);
    })

    update("users.matt.count", 5).then(data => {
        console.log(data);
    })

    remove("users.matt").then(data => {
        console.log(data);
    })

    query("sessions", `child.count > 0`).then(data => {
        console.log(data);
    })

    wsFunction("custom1", 23).then(data => {
        console.log(data);
    })

    //all subscriptions use value, get, update, remove. This subscribes to that action

    getSub("value@sessions", data => {
        console.log(data);
    });

    querySub("value@sessions", "child.count == 4", data => {
        console.log(data);
    });

    getSubChanged("value@sessions", data => {
        console.log(data);
    });

    querySubChanged("value@sessions", "child.count != 4", data => {
        console.log(data);
    });

    setFile(undefined, blob).then(data => {
        console.log(data);
    })
});