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 async function getCurrentDate() {
    return currentDate;
}

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';
    #dbClient = null;

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

    async connect() {
        try {
            // Проверяем подключение, выполняя простой запрос
            const conn = await this.#dbClient.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.#dbClient.end();
        console.log("DISCONNECT");
    }

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

    async getOrders() {
        try {
            const raw_orders = await this.#dbClient.query('SELECT * FROM orders ORDER BY order_date ASC');
            console.log("All orders:", raw_orders);
            
            const items = await this.#dbClient.query(
                `SELECT order_items.*, products.name AS product_name FROM order_items
                JOIN products ON order_items.product_id = products.id`
            );
            console.log("All order items:", items);
            
            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 (!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.#dbClient.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.#dbClient.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.#dbClient.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) {
            return Promise.reject({
                type: DB_USER_ERROR,
                error: new Error("Order ID is required")
            });
        }

        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")
            });
        }

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

            if (!order){
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Order not found")
                });
            }
            
            const updatedName = customer_name;
            const updatedDate = orderDate;

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

        } catch(err){
            return Promise.reject({
                type: DB_INTERNAL_ERROR,
                error: new Error("Server error")
            });
        }
    }

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

            for (const item of orderItems){
                await this.#dbClient.query('UPDATE products SET quantity = quantity + ? WHERE id = ?', 
                    [item.quantity, item.product_id]
                );
            }
            await this.#dbClient.query(
                `DELETE FROM orders WHERE id = ?`,
                [order_id]
            );
        } catch(err){
            return Promise.reject({
                type: DB_INTERNAL_ERROR,
                error: new Error("Server error")
            });
        }
    }

    async addOrderItem({ orderId, productId, quantity }){
        await this.#dbClient.query('BEGIN');
        try {
            const product = await this.#dbClient.query(
                'SELECT quantity FROM products WHERE id = ?', [productId]
            );

            const productRow = product?.[0];
            if (!productRow || productRow.quantity < quantity){
                return Promise.reject({
                    type: DB_USER_ERROR,
                    error: new Error("Insufficient product quantity")
                });
            }

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

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

            await this.#dbClient.query('COMMIT');
        } catch (err){
            await this.#dbClient.query('ROLLBACK');
            return Promise.reject();
        }
    }

    async updateOrderItem({ itemId, quantity }){
        await this.#dbClient.query('BEGIN');
        try {
            const item = await this.#dbClient.query(
                'SELECT product_id, quantity FROM order_items WHERE id = ?', [itemId]
            );

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

            const diff = quantity - itemRow.quantity;

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

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

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

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

            await this.#dbClient.query('COMMIT');
        } catch (err){
            await this.#dbClient.query('ROLLBACK');
            return Promise.reject();
        }
    }

    async deleteOrderItem(itemId){
        await this.#dbClient.query('BEGIN');
        try {
            const item = await this.#dbClient.query(
                'SELECT product_id, quantity FROM order_items WHERE id = ?', [itemId]
            );

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

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

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

            await this.#dbClient.query('COMMIT');
        } catch (err){
            await this.#dbClient.query('ROLLBACK');
            return Promise.reject();
        }
    }

    async moveOrderItem( {itemId, targetOrderId }){
        await this.#dbClient.query('BEGIN');
        try {
            const item = await this.#dbClient.query(
                'SELECT id, order_id FROM order_items WHERE id = ?', [itemId]
            );

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

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

            await this.#dbClient.query('COMMIT');
        } catch (err){
            await this.#dbClient.query('ROLLBACK');
            return Promise.reject();
        }
    }
}