/**
 * @param {string} key
 * @returns {Array}
 */

app.use("/getServerVehicles.lvorex", express.json())
app.post("/getServerVehicles.lvorex", async (req, res) => {
    const postBody = req.body;
    const { keyFound, userKey } = await controlKey(req, postBody.key);

    if (keyFound === false) return res.json({ code: 404, message: "Not authorized." });
    
    const PermissionCheck = await checkPermission(userKey.rank, "Vehicles", 0);
    if (!PermissionCheck) return res.json({ code: 401, message: "Your rank is not enough." });
    
    const vehicles = [];

    if (config.Framework.includes("qb")) {
        const SharedVehicles = await LV.GetAllServerVehicles();
        
        if (!SharedVehicles || SharedVehicles.length === 0) {
            return res.json({ code: 404, message: "No vehicles found or failed to retrieve vehicles." });
        }

        for (const value of SharedVehicles) {
            let result = await query(`
                SELECT * FROM \`madmin_vehicles\`
                WHERE \`model\` = '${value.model}'
            `);

            if (result === false) {
                return res.json({ code: 404, message: "SQL Error Appeared." });
            }

            let vehicleClass = "E";
            let vehicleCategory = "Vanilla";
            let vehicleImportStatus = 0;
            let vehicleImage = "img/CarImage.png";

            if (result.length !== 0) {
                result = result[0];  
                vehicleClass = result.class;
                vehicleCategory = result.category;
                vehicleImportStatus = result.import;
                vehicleImage = result.image;
            } else {
                result = await query(`
                    INSERT INTO \`madmin_vehicles\` (
                        \`model\`,
                        \`class\`,
                        \`category\`,
                        \`import\`
                    ) VALUES (
                        '${value.model}',
                        '${vehicleClass}',
                        '${vehicleCategory}',
                        0
                    )
                `);

                if (result === false) {
                    return res.json({ code: 404, message: "SQL Error Appeared." });
                }
            }

            vehicles.push({
                brand: value.brand,
                label: value.name,
                mainCategory: vehicleCategory,
                class: vehicleClass, // E D C B A A+ S S+
                model: value.model,
                shop: value.shop,
                category: value.categoryLabel ?? value.category,
                categoryValue: value.category,
                hash: GetHashKey(value.model),
                price: value.price,
                import: vehicleImportStatus,
                image: vehicleImage
            });
        }
    } else if (config.Framework.includes("esx")) {
        let result = await LV.GetAllServerVehicles();

        if (!result || result.length === 0) {
            return res.json({ code: 404, message: "No vehicles found or failed to retrieve vehicles." });
        }

        for await (const vehicle of result) {
            let MAdminVehicle = await query(`
                SELECT * FROM \`madmin_vehicles\`
                WHERE \`model\` = '${vehicle.model}'
            `);

            if (MAdminVehicle === false) return res.json({ code: 404, message: "SQL Error Appeared." });
            MAdminVehicle = MAdminVehicle[0];
            let vehicleClass = "E";
            let vehicleCategory = "Vanilla";
            let vehicleImportStatus = 0;
            let vehicleImage = "img/CarImage.png";

            if (MAdminVehicle) {
                vehicleClass = MAdminVehicle.class;
                vehicleCategory = MAdminVehicle.category;
                vehicleImportStatus = Number(MAdminVehicle.import);
                vehicleImage = MAdminVehicle.image;
            } else {
                result = await query(`
                    INSERT INTO \`madmin_vehicles\` (
                        \`model\`,
                        \`class\`,
                        \`category\`,
                        \`import\`,
                        \`image\`
                    ) VALUES (
                        '${vehicle.model}',
                        '${vehicleClass}',
                        '${vehicleCategory}',
                        0,
                        '${vehicleImage}'
                    )
                `);

                if (result === false) return res.json({ code: 404, message: "SQL Error Appeared." });
            }

            vehicles.push({
                brand: vehicle.name.split(" ")[0],
                label: vehicle.name,
                mainCategory: vehicleCategory,
                class: vehicleClass, // E D C B A A+ S S+
                model: vehicle.model,
                shop: "Vehicle Shop",
                category: vehicle.category,
                categoryValue: vehicle.category,
                hash: GetHashKey(vehicle.model),
                price: vehicle.price,
                import: vehicleImportStatus,
                image: vehicleImage
            });
        }
    }

    res.json({ code: 200, message: vehicles });
});


/**
 * @param {string} key
 * @returns {Array}
 */

app.use("/getOwnedVehicles.lvorex", express.json())
app.post("/getOwnedVehicles.lvorex", async (req, res) => {
    const postBody = req.body
    const { keyFound, userKey } = await controlKey(req, postBody.key)

    if (keyFound === false) return res.json({ code: 404, message: "Not authorized." })
    const PermissionCheck = await checkPermission(userKey.rank, "Vehicles", 2)
    if (!PermissionCheck) return res.json({ code: 401, message: "Your rank is not enough." })
    const vehicles = []

    if (config.Framework.includes("qb")) {
        let result = await query(`
            select * from \`player_vehicles\`
        `)
        if (result === false) return res.json({ code: 404, message: "SQL Error Appeared." })
        if (result.length === 0) return res.json({ code: 200, message: [] })

        for await (const vehicle of result) {
            const Vehicles = await LV.GetAllServerVehicles()
            const VehicleCredentials = Vehicles.find(v => v.model === vehicle.vehicle)
            let ownerName = "Not Found."

            let ownerResult = await query(`
                select * from \`players\`
                where \`citizenid\` = '${vehicle.citizenid}'
            `)
            if (ownerResult === false) return res.json({ code: 404, message: "SQL Error Appeared." })
            if (ownerResult.length !== 0) {
                ownerResult = ownerResult[0]
                const CharInfo = JSON.parse(ownerResult.charinfo)
                ownerName = `${CharInfo.firstname} ${CharInfo.lastname}`
            }

            let vehicleClass = "C"
            let vehicleCategory = "Vanilla"
            let vehicleImportStatus = 0
            let vehicleImage = "img/CarImage.png"
            let vehicleOtherCredentialsResult = await query(`
                select * from \`madmin_vehicles\`
                where \`model\` = '${vehicle.vehicle}'
            `)
            if (vehicleOtherCredentialsResult === false) return res.json({ code: 404, message: "SQL Error Appeared." })
            if (vehicleOtherCredentialsResult.length !== 0) {
                vehicleOtherCredentialsResult = vehicleOtherCredentialsResult[0]
                
                vehicleClass = vehicleOtherCredentialsResult.class
                vehicleCategory = vehicleOtherCredentialsResult.category
                vehicleImportStatus = vehicleOtherCredentialsResult.import
                vehicleImage = vehicleOtherCredentialsResult.image
            }

            vehicles.push({
                brand: VehicleCredentials ? VehicleCredentials.brand : "Not Found",
                label: VehicleCredentials ? VehicleCredentials.name : "Not Found",
                mainCategory: vehicleCategory,
                class: vehicleClass,
                import: vehicleImportStatus,
                categoryValue: VehicleCredentials ? VehicleCredentials.category : "Not Found.",
                image: vehicleImage,

                plate: vehicle.plate,
                state: vehicle.state === 1 ? "In Garage" : "Outside",
                owner: `owned by ${ownerName}`,
                distance: `${parseInt(vehicle.drivingdistance / 1000)} km`,
                price: VehicleCredentials ? VehicleCredentials.price : 0,

                ownerCitizenid: vehicle.citizenid
            })
        }
    } else if (config.Framework.includes("esx")) {
        let result = await query(`
            select * from \`owned_vehicles\`
        `)
        if (result === false) return res.json({ code: 404, message: "SQL Error Appeared." })
        if (result.length === 0) return res.json({ code: 200, message: [] })

        for await (const vehicle of result) {
            let VehicleSQLJSon = JSON.parse(vehicle.vehicle)
            let VehicleCredentials = await LV.GetAllServerVehicles()
            VehicleCredentials.forEach(v => {
                if (!VehicleCredentials.length) return
                if (GetHashKey(v.model) === VehicleSQLJSon.model) {
                    VehicleCredentials = v
                    return
                }
            })
            if (!VehicleCredentials.name) continue

            let ownerName = await query(`
                select * from \`users\`
                where \`identifier\` = '${vehicle.owner}'
            `)
            if (ownerName === false) return res.json({ code: 404, message: "SQL Error Appeared." })
            if (ownerName.length !== 0) {
                ownerName = ownerName[0]
                ownerName = `${ownerName.firstname} ${ownerName.lastname}`
            } else {
                ownerName = "Not Found."
            }

            let vehicleClass = "C"
            let vehicleCategory = "Vanilla"
            let vehicleImportStatus = 0
            let vehicleImage = "img/CarImage.png"
            let vehicleOtherCredentialsResult = await query(`
                select * from \`madmin_vehicles\`
                where \`model\` = '${vehicle.vehicle}'
            `)
            if (vehicleOtherCredentialsResult === false) return res.json({ code: 404, message: "SQL Error Appeared." })
            if (vehicleOtherCredentialsResult.length !== 0) {
                vehicleOtherCredentialsResult = vehicleOtherCredentialsResult[0]
                
                vehicleClass = vehicleOtherCredentialsResult.class
                vehicleCategory = vehicleOtherCredentialsResult.category
                vehicleImportStatus = vehicleOtherCredentialsResult.import
                vehicleImage = vehicleOtherCredentialsResult.image
            }

            vehicles.push({
                brand: VehicleCredentials.name.split(" ")[0],
                label: VehicleCredentials.name,
                mainCategory: vehicleCategory,
                class: vehicleClass,
                import: vehicleImportStatus,
                categoryValue: VehicleCredentials.category,
                image: vehicleImage,

                plate: vehicle.plate,
                state: vehicle.stored === 1 ? "In Garage" : "Outside",
                owner: `owned by ${ownerName}`,
                distance: `${vehicle.mileage} km`,
                price: VehicleCredentials.price,

                ownerCitizenid: vehicle.owner
            })
        }
    }

    res.json({ code: 200, message: vehicles })
})