import mdb from "mariadb"

export const DB_INTERNAL_ERROR = 'INTERNAL';
export const DB_USER_ERROR = 'USER';

let currentDate = (new Date()).toISOString().slice(0, 10);

export function getCurrentDate() {
    return currentDate;
}

function Random_Increase() {
    return Math.floor(Math.random() * 5) + 1;
}

export async function setCurrentDate(newDate) {
    currentDate = newDate;
    console.log(`📅 Date changed to: ${currentDate}`);
}

export default class DBAdapter {
    #dbhost = 'localhost';
    #dbPort = 3306;
    #dbName = 'N';
    #dbUserLogin = 'u';
    #dbUserPassword = 'p';
    #pool = null;

    constructor({
        dbHost,
        dbPort,
        dbName,
        dbUserLogin,
        dbUserPassword
    }) {
        this.#dbhost = dbHost;
        this.#dbPort = dbPort;
        this.#dbName = dbName;
        this.#dbUserLogin = dbUserLogin;
        this.#dbUserPassword = dbUserPassword;
        this.#pool = mdb.createPool({
            host: this.#dbhost,
            port: this.#dbPort,
            database: this.#dbName,
            user: this.#dbUserLogin,
            password: this.#dbUserPassword,
            dateStrings: true,
            acquireTimeout: 10000,
        });
    }

    async #getConnection() {
        return await this.#pool.getConnection();
    }
    
    async connect() {
        try {
            const conn = await this.#pool.getConnection();
            console.log("✅ Database connection test successful");
            conn.release();
        } catch (err) {
            console.error("❌ Database connection failed:", err.message);
            return Promise.reject();
        }
    }

    async disconnect() {
        await this.#pool.end();
        console.log("DISCONNECT");
    }

    async stock(){
        try {
            const products = await this.#pool.query('SELECT id FROM products');
            for (const product of products) {
                const increment = Random_Increase();
                await this.#pool.query('UPDATE products SET quantity = quantity + ? WHERE id = ?', [
                    increment,
                    product.id
                ]);
            }            
        } catch (err){
            return Promise.reject({
                type: err
            }
            );
        }
    }

    async getProducts() {
        try {
            const products = await this.#pool.query('SELECT * FROM products ORDER BY name');
            return products;
        } catch(err){
            console.log(`WHOOPS`);
            return Promise.reject();
        }
    }

    async getOrders() {
        try {
            const raw_orders = await this.#pool.query('SELECT * FROM orders ORDER BY order_date ASC');
            
            const items = await this.#pool.query(
                `SELECT order_items.*, products.name AS product_name FROM order_items
                JOIN products ON order_items.product_id = products.id`
            );
            
            const groupedItems = {};
            if (items && items.length > 0) {
                items.forEach(item => {
                    const orderId = item.order_id;
                    if (!groupedItems[orderId]) {
                        groupedItems[orderId] = [];
                    }
                    groupedItems[orderId].push(item);
                });
            }
            
            const ordersWithItems = raw_orders.map(order => {
                return {
                    ...order,
                    items: groupedItems[order.id] || []
                };
            });
            
            return ordersWithItems;
        } catch(err) {
            console.log(`WHOOPS: ${err.message}`);
            return Promise.reject(err);
        }
    }

    async addOrder({ id, customer_name, orderDate} ){
        if (!id || !customer_name || !orderDate){
            return Promise.reject({
                type: DB_USER_ERROR,
                error: new Error("Empty in customer name or order date")
            });
        }
        const currentDate = await getCurrentDate();
        if (orderDate < currentDate){
            return Promise.reject({
                type: DB_USER_ERROR,
                error: new Error("Invalid order date")
            });
        }
        try {
            await this.#pool.query('INSERT INTO orders (id, customer_name, order_date) VALUES (?, ?, ?)',
                [id, customer_name, orderDate]
            );
        } catch(err){
            return Promise.reject({
                type: DB_INTERNAL_ERROR,
                error: new Error("Server error")
            });
        }
    }

    async getOrdersByDate(date){
        try {
            const order_ids = await this.#pool.query('SELECT id FROM orders WHERE order_date = ?', [date]);
            return order_ids;
        } catch(err){
            return Promise.reject();
        }
    }

    async clearOrders(orderIds) {
        if (!orderIds || orderIds.length === 0) {
            console.log("No orders to delete");
            return;
        }
        
        try {
            const placeholders = orderIds.map(() => '?').join(',');
            
            const result = await this.#pool.query(
                `DELETE FROM orders WHERE id IN (${placeholders})`,
                orderIds
            );
            
            console.log(`✅ Deleted ${result.affectedRows} orders with IDs:`, orderIds);
            
        } catch(err) {
            console.error(`❌ Error deleting orders:`, err.message);
            return Promise.reject();
        }
    }

    async changeOrderInfo({ id, customer_name, orderDate }) {
        if (!id || !customer_name || !orderDate) {
            return Promise.reject({
                type: DB_USER_ERROR,
                error: new Error("Order ID, name or date is required!"),
                message: "Order ID, name or date is required!" // Добавляем message напрямую
            });
        }

        const currentDate = await getCurrentDate();
        if (orderDate < currentDate) {
            return Promise.reject({
                type: DB_USER_ERROR,
                error: new Error("Order date cannot be less than current date"),
                message: "Order date cannot be less than current date"
            });
        }

        try {
            const order = await this.#pool.query('SELECT * FROM orders WHERE id = ?', [id]);

            if (!order || order.length === 0) { // Исправлено: проверяем length
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Order not found"),
                    message: "Order not found"
                });
            }
            
            const updatedName = customer_name;
            const updatedDate = orderDate;

            await this.#pool.query('UPDATE orders SET customer_name = ?, order_date = ? WHERE id = ?',
                [updatedName, updatedDate, id]
            );

        } catch(err) {
            console.error('Database error in changeOrderInfo:', err);
            return Promise.reject({
                type: DB_INTERNAL_ERROR,
                error: new Error("Server error"),
                message: err.message || "Database operation failed",
                details: err.message
            });
        }
    }

    async deleteOrderById(order_id) {
        let connection;
        
        try {
            connection = await this.#pool.getConnection();
            await connection.beginTransaction();
            
            const orderItems = await connection.query(
                `SELECT product_id, quantity FROM order_items WHERE order_id = ?`,
                [order_id]
            );

            for (const item of orderItems) {
                await connection.query(
                    'UPDATE products SET quantity = quantity + ? WHERE id = ?', 
                    [item.quantity, item.product_id]
                );
            }
            
            await connection.query(
                `DELETE FROM order_items WHERE order_id = ?`,
                [order_id]
            );
            
            await connection.query(
                `DELETE FROM orders WHERE id = ?`,
                [order_id]
            );

            await connection.commit();
            connection.release();
            
        } catch (err) {
            if (connection) {
                try {
                    await connection.rollback();
                } catch (rollbackErr) {
                    console.error('Rollback error:', rollbackErr.message);
                }
                connection.release();
            }
            
            return Promise.reject({
                type: DB_INTERNAL_ERROR,
                error: new Error("Failed to delete order"),
                details: err.message
            });
        }
    }

    async addOrderItem({ orderId, productId, quantity }) {
        let connection;
        
        try {
            connection = await this.#pool.getConnection();
            
            await connection.beginTransaction();
            
            const orderCheck = await connection.query(
                'SELECT id FROM orders WHERE id = ?', 
                [orderId]
            );
            
            if (!orderCheck || orderCheck.length === 0) {
                await connection.rollback();
                connection.release();
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Order not found")
                });
            }
            
            const product = await connection.query(
                'SELECT id, quantity FROM products WHERE id = ? FOR UPDATE', 
                [productId]
            );

            const productRow = product?.[0];
            
            if (!productRow) {
                await connection.rollback();
                connection.release();
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Product not found")
                });
            }
            
            if (productRow.quantity < quantity) {
                await connection.rollback();
                connection.release();
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Insufficient product quantity")
                });
            }

            await connection.query(
                'UPDATE products SET quantity = quantity - ? WHERE id = ?',
                [quantity, productId]
            );

            const result = await connection.query(
                'INSERT INTO order_items (order_id, product_id, quantity) VALUES (?, ?, ?)',
                [orderId, productId, quantity]
            );

            await connection.commit();
            
            connection.release();
            
            return result.insertId;
            
        } catch (err) {
            if (connection) {
                try {
                    await connection.rollback();
                } catch (rollbackErr) {
                    console.error('Rollback error:', rollbackErr.message);
                }
                connection.release();
            }
            
            console.error('Transaction error:', err);
            
            let errorType = DB_INTERNAL_ERROR;
            let userMessage = "Database operation failed";
            let retryable = false;
            
            if (err.code === 'ER_LOCK_WAIT_TIMEOUT' || err.errno === 1205) {
                errorType = 'DB_CONFLICT';
                userMessage = "System is busy. Please try again in a moment.";
                retryable = true;
            } else if (err.code === 'ER_DUP_ENTRY') {
                errorType = DB_USER_ERROR;
                userMessage = "Item already exists in the order";
            }
            
            return Promise.reject({
                type: errorType,
                error: new Error(userMessage),
                details: err.message,
                code: err.code,
                retryable: retryable,
                originalError: err
            });
        }
    }

    async updateOrderItem({ itemId, quantity, productId }) {
        let connection;
        
        try {
            if (!itemId || !Number.isFinite(quantity) || quantity <= 0) {
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Invalid item or quantity")
                });
            }

            connection = await this.#pool.getConnection();
            await connection.beginTransaction();
            
            const item = await connection.query(
                'SELECT product_id, quantity FROM order_items WHERE id = ? FOR UPDATE', 
                [itemId]
            );

            const itemRow = item?.[0];
            if (!itemRow) {
                await connection.rollback();
                connection.release();
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Order item not found")
                });
            }

            const targetProductId = productId ?? itemRow.product_id;

            if (targetProductId !== itemRow.product_id) {
                const newProduct = await connection.query(
                    'SELECT quantity FROM products WHERE id = ? FOR UPDATE',
                    [targetProductId]
                );
                const newProductRow = newProduct?.[0];
                if (!newProductRow) {
                    await connection.rollback();
                    connection.release();
                    return Promise.reject({
                        type: DB_USER_ERROR,
                        error: new Error("Product not found")
                    });
                }
                if (newProductRow.quantity < quantity) {
                    await connection.rollback();
                    connection.release();
                    return Promise.reject({
                        type: DB_USER_ERROR,
                        error: new Error("Insufficient product quantity")
                    });
                }

                await connection.query(
                    'UPDATE products SET quantity = quantity + ? WHERE id = ?',
                    [itemRow.quantity, itemRow.product_id]
                );

                await connection.query(
                    'UPDATE products SET quantity = quantity - ? WHERE id = ?',
                    [quantity, targetProductId]
                );

                await connection.query(
                    'UPDATE order_items SET product_id = ?, quantity = ? WHERE id = ?',
                    [targetProductId, quantity, itemId]
                );

                await connection.commit();
                connection.release();
                return;
            }

            const diff = quantity - itemRow.quantity;

            if (diff > 0) {
                const product = await connection.query(
                    'SELECT quantity FROM products WHERE id = ? FOR UPDATE', 
                    [itemRow.product_id]
                );

                const productRow = product?.[0];
                if (!productRow || productRow.quantity < diff) {
                    await connection.rollback();
                    connection.release();
                    return Promise.reject({
                        type: DB_USER_ERROR,
                        error: new Error("Insufficient product quantity")
                    });
                }
                
                await connection.query(
                    'UPDATE products SET quantity = quantity - ? WHERE id = ?',
                    [diff, itemRow.product_id]
                );
            }

            if (diff < 0) {
                await connection.query(
                    'UPDATE products SET quantity = quantity + ? WHERE id = ?',
                    [-diff, itemRow.product_id]
                );                
            }

            await connection.query(
                'UPDATE order_items SET quantity = ? WHERE id = ?',
                [quantity, itemId]
            );

            await connection.commit();
            connection.release();
            
        } catch (err) {
            if (connection) {
                try {
                    await connection.rollback();
                } catch (rollbackErr) {
                    console.error('Rollback error:', rollbackErr.message);
                }
                connection.release();
            }
            
            return Promise.reject({
                type: DB_INTERNAL_ERROR,
                error: new Error("Failed to update order item"),
                details: err.message
            });
        }
    }

    async deleteOrderItem(itemId) {
        let connection;
        
        try {
            connection = await this.#pool.getConnection();
            await connection.beginTransaction();
            
            const item = await connection.query(
                'SELECT product_id, quantity FROM order_items WHERE id = ? FOR UPDATE', 
                [itemId]
            );

            const itemRow = item?.[0];
            if (!itemRow) {
                await connection.rollback();
                connection.release();
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Order item not found")
                });
            }

            await connection.query(
                'UPDATE products SET quantity = quantity + ? WHERE id = ?',
                [itemRow.quantity, itemRow.product_id]
            );

            await connection.query(
                'DELETE FROM order_items WHERE id = ?',
                [itemId]
            );

            await connection.commit();
            connection.release();
            
        } catch (err) {
            if (connection) {
                try {
                    await connection.rollback();
                } catch (rollbackErr) {
                    console.error('Rollback error:', rollbackErr.message);
                }
                connection.release();
            }
            
            console.error('Delete order item error:', err);
            
            return Promise.reject({
                type: DB_INTERNAL_ERROR,
                error: new Error("Failed to delete order item"),
                details: err.message,
                itemId: itemId
            });
        }
    }

    async moveOrderItem({ itemId, targetOrderId }) {
        let connection;
        
        try {
            connection = await this.#pool.getConnection();
            await connection.beginTransaction();
            
            // Проверяем существование целевого заказа
            const targetOrderCheck = await connection.query(
                'SELECT id FROM orders WHERE id = ?', 
                [targetOrderId]
            );
            
            if (!targetOrderCheck || targetOrderCheck.length === 0) {
                await connection.rollback();
                connection.release();
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Target order not found")
                });
            }
            
            const item = await connection.query(
                'SELECT id, order_id FROM order_items WHERE id = ? FOR UPDATE', 
                [itemId]
            );

            const itemRow = item?.[0];
            if (!itemRow) {
                await connection.rollback();
                connection.release();
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Order item not found")
                });
            }

            await connection.query(
                'UPDATE order_items SET order_id = ? WHERE id = ?',
                [targetOrderId, itemId]
            );

            await connection.commit();
            connection.release();
            
        } catch (err) {
            if (connection) {
                try {
                    await connection.rollback();
                } catch (rollbackErr) {
                    console.error('Rollback error:', rollbackErr.message);
                }
                connection.release();
            }
            
            return Promise.reject({
                type: DB_INTERNAL_ERROR,
                error: new Error("Failed to move order item"),
                details: err.message
            });
        }
    }
}