import logging.config
from logger_helper.logger_helper import LOGGING_CONFIG
from datetime import datetime, timedelta
from typing import Any

logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger("requests")

from app.telegram.database.models import async_session
from app.telegram.database.models import User_Telegram_Id as UTi
from app.telegram.database.models import User_Main_Settings as UMS
from app.telegram.database.models import User_Bybit_API as UBA
from app.telegram.database.models import User_Symbol
from app.telegram.database.models import User_Risk_Management_Settings as URMS
from app.telegram.database.models import User_Condition_Settings as UCS
from app.telegram.database.models import User_Additional_Settings as UAS
from app.telegram.database.models import Trading_Mode
from app.telegram.database.models import Margin_type
from app.telegram.database.models import Trigger
from app.telegram.database.models import USER_DEALS, UserTimer

import app.telegram.functions.functions as func  # functions

from sqlalchemy import select, delete, update


# SET_DB
async def save_tg_id_new_user(tg_id):
    async with async_session() as session:
        user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id))

        if not user:
            session.add(UTi(tg_id=tg_id))

            logger.info("Новый пользователь был добавлен в бд %s", tg_id)

        await session.commit()


async def set_new_user_bybit_api(tg_id):
    async with async_session() as session:
        user = await session.scalar(select(UBA).where(UBA.tg_id == tg_id))

        if not user:
            session.add(UBA(
                tg_id=tg_id,
            ))

        await session.commit()


async def set_new_user_symbol(tg_id):
    async with async_session() as session:
        user = await session.scalar(select(User_Symbol).where(User_Symbol.tg_id == tg_id))

        if not user:
            session.add(User_Symbol(
                tg_id=tg_id
            ))

            logger.info(f"Symbol был успешно добавлен %s", tg_id)

        await session.commit()


async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -> None:
    async with async_session() as session:
        settings = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))

        if not settings:
            session.add(UMS(
                tg_id=tg_id,
                trading_mode=trading_mode,
                margin_type=margin_type,
            ))

            logger.info("Основные настройки нового пользователя были заполнены%s", tg_id)

        await session.commit()


async def set_new_user_default_risk_management_settings(tg_id) -> None:
    async with async_session() as session:
        settings = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))

        if not settings:
            session.add(URMS(
                tg_id=tg_id
            ))

            logger.info("Риск-Менеджмент настройки нового пользователя были заполнены %s", tg_id)

        await session.commit()


async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
    async with async_session() as session:
        settings = await session.scalar(select(UCS).where(UCS.tg_id == tg_id))

        if not settings:
            session.add(UCS(
                tg_id=tg_id,
                trigger=trigger
            ))

            logger.info("Условные настройки нового пользователя были заполнены %s", tg_id)

        await session.commit()


async def set_new_user_default_additional_settings(tg_id) -> None:
    async with async_session() as session:
        settings = await session.scalar(select(UAS).where(UAS.tg_id == tg_id))

        if not settings:
            session.add(UAS(
                tg_id=tg_id,
            ))

            logger.info("Дополнительные настройки нового пользователя были заполнены %s", tg_id)

        await session.commit()


# GET_DB
async def check_user(tg_id):
    async with async_session() as session:
        user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id))
        return user


async def get_bybit_api_key(tg_id):
    async with async_session() as session:
        api_key = await session.scalar(select(UBA.api_key).where(UBA.tg_id == tg_id))
        return api_key


async def get_bybit_secret_key(tg_id):
    async with async_session() as session:
        secret_key = await session.scalar(select(UBA.secret_key).where(UBA.tg_id == tg_id))
        return secret_key


async def get_symbol(tg_id):
    async with async_session() as session:
        symbol = await session.scalar(select(User_Symbol.symbol).where(User_Symbol.tg_id == tg_id))
        return symbol


async def get_user_trades(tg_id):
    async with async_session() as session:
        query = select(USER_DEALS.symbol, USER_DEALS.side).where(USER_DEALS.tg_id == tg_id)
        result = await session.execute(query)
        trades = result.all()
        return trades


async def update_user_trades(tg_id, **kwargs):
    async with async_session() as session:
        query = update(USER_DEALS).where(USER_DEALS.tg_id == tg_id).values(**kwargs)
        await session.execute(query)
        await session.commit()


async def delete_user_trade(tg_id: int, symbol: str):
    async with async_session() as session:
        await session.execute(
            USER_DEALS.__table__.delete().where(
                (USER_DEALS.tg_id == tg_id) & (USER_DEALS.symbol == symbol)
            )
        )
        await session.commit()


async def get_for_registration_trading_mode():
    async with async_session() as session:
        mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.id == 1))
        return mode


async def get_for_registration_margin_type():
    async with async_session() as session:
        type = await session.scalar(select(Margin_type.type).where(Margin_type.id == 1))
        return type


async def get_for_registration_trigger():
    async with async_session() as session:
        trigger = await session.scalar(select(Trigger.trigger).where(Trigger.id == 1))
        return trigger


async def get_user_main_settings(tg_id):
    async with async_session() as session:
        user = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))

        if user:
            logger.info("Получение основных настроек пользователя %s", tg_id)

            trading_mode = await session.scalar(select(UMS.trading_mode).where(UMS.tg_id == tg_id))
            margin_mode = await session.scalar(select(UMS.margin_type).where(UMS.tg_id == tg_id))
            size_leverage = await session.scalar(select(UMS.size_leverage).where(UMS.tg_id == tg_id))
            starting_quantity = await session.scalar(select(UMS.starting_quantity).where(UMS.tg_id == tg_id))
            martingale_factor = await session.scalar(select(UMS.martingale_factor).where(UMS.tg_id == tg_id))
            maximal_quantity = await session.scalar(select(UMS.maximal_quantity).where(UMS.tg_id == tg_id))

            data = {
                'trading_mode': trading_mode,
                'margin_type': margin_mode,
                'size_leverage': size_leverage,
                'starting_quantity': starting_quantity,
                'martingale_factor': martingale_factor,
                'maximal_quantity': maximal_quantity
            }

            return data


async def get_user_risk_management_settings(tg_id):
    async with async_session() as session:
        user = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))

        if user:
            logger.info("Получение риск-менеджмента настроек пользователя %s", tg_id)

            price_profit = await session.scalar(select(URMS.price_profit).where(URMS.tg_id == tg_id))
            price_loss = await session.scalar(select(URMS.price_loss).where(URMS.tg_id == tg_id))
            max_risk_deal = await session.scalar(select(URMS.max_risk_deal).where(URMS.tg_id == tg_id))
            commission_fee = await session.scalar(select(URMS.commission_fee).where(URMS.tg_id == tg_id))

            data = {
                'price_profit': price_profit,
                'price_loss': price_loss,
                'max_risk_deal': max_risk_deal,
                'commission_fee': commission_fee,
            }

            return data


# UPDATE_SYMBOL
async def update_symbol(tg_id, symbol) -> None:
    async with async_session() as session:
        await session.execute(update(User_Symbol).where(User_Symbol.tg_id == tg_id).values(symbol=symbol))

        await session.commit()


async def update_api_key(tg_id, api):
    async with async_session() as session:
        api_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(api_key=api))

        await session.commit()


async def update_secret_key(tg_id, api):
    async with async_session() as session:
        secret_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key=api))

        await session.commit()


# UPDATE_MAIN_SETTINGS_DB
async def update_trade_mode_user(tg_id, trading_mode) -> None:
    async with async_session() as session:
        mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.mode == trading_mode))

        if mode:
            logger.info("Изменен трейд мод %s", tg_id)
            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode=mode))

            await session.commit()


async def update_margin_type(tg_id, margin_type) -> None:
    async with async_session() as session:
        type = await session.scalar(select(Margin_type.type).where(Margin_type.type == margin_type))

        if type:
            logger.info("Изменен тип маржи %s", tg_id)
            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(margin_type=type))

            await session.commit()


async def update_size_leverange(tg_id, num):
    async with async_session() as session:
        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(size_leverage=num))

        await session.commit()


async def update_starting_quantity(tg_id, num):
    async with async_session() as session:
        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(starting_quantity=num))

        await session.commit()


async def update_martingale_factor(tg_id, num):
    async with async_session() as session:
        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_factor=num))

        await session.commit()


async def update_maximal_quantity(tg_id, num):
    async with async_session() as session:
        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(maximal_quantity=num))

        await session.commit()


# UPDATE_RISK_MANAGEMENT_SETTINGS_DB

async def update_price_profit(tg_id, num):
    async with async_session() as session:
        await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_profit=num))

        await session.commit()


async def update_price_loss(tg_id, num):
    async with async_session() as session:
        await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_loss=num))

        await session.commit()


async def update_max_risk_deal(tg_id, num):
    async with async_session() as session:
        await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(max_risk_deal=num))

        await session.commit()


async def update_entry_order_type(tg_id, order_type):
    async with async_session() as session:
        await session.execute(
            update(UMS)
            .where(UMS.tg_id == tg_id)
            .values(entry_order_type=order_type)
        )
        await session.commit()


async def get_entry_order_type(tg_id: object) -> str | None | Any:
    async with async_session() as session:
        order_type = await session.scalar(
            select(UMS.entry_order_type).where(UMS.tg_id == tg_id)
        )
        # Если в базе не установлен тип — возвращаем значение по умолчанию
        return order_type or 'Market'


async def get_limit_price(tg_id):
    async with async_session() as session:
        result = await session.execute(
            select(UMS.limit_order_price)
            .where(UMS.tg_id == tg_id)
        )
        price = result.scalar_one_or_none()
        if price:
            try:
                return float(price)
            except ValueError:
                return None
        return None


async def update_limit_price(tg_id, price):
    async with async_session() as session:
        await session.execute(
            update(UMS)
            .where(UMS.tg_id == tg_id)
            .values(limit_order_price=str(price))
        )
        await session.commit()


async def update_commission_fee(tg_id, num):
    async with async_session() as session:
        await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(commission_fee=num))

        await session.commit()


async def get_user_timer(tg_id):
    async with async_session() as session:
        result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
        user_timer = result.scalars().first()

        if not user_timer:
            logging.info(f"No timer found for user {tg_id}")
            return None

        timer_minutes = user_timer.timer_minutes
        timer_start = user_timer.timer_start
        timer_end = user_timer.timer_end

        logging.info(f"Timer data for tg_id={tg_id}: "
                     f"timer_minutes={timer_minutes}, "
                     f"timer_start={timer_start}, "
                     f"timer_end={timer_end}")

        remaining = None
        if timer_end:
            remaining = max(0, int((timer_end - datetime.utcnow()).total_seconds() // 60))

        return {
            "timer_minutes": timer_minutes,
            "timer_start": timer_start,
            "timer_end": timer_end,
            "remaining_minutes": remaining
        }


async def update_user_timer(tg_id, minutes: int):
    async with async_session() as session:
        try:
            async with async_session() as session:
                timer_start = None
                timer_end = None

                if minutes > 0:
                    timer_start = datetime.utcnow()
                    timer_end = timer_start + timedelta(minutes=minutes)

                result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
                user_timer = result.scalars().first()

                if user_timer:
                    user_timer.timer_minutes = minutes
                    user_timer.timer_start = timer_start
                    user_timer.timer_end = timer_end
                else:
                    user_timer = UserTimer(
                        tg_id=tg_id,
                        timer_minutes=minutes,
                        timer_start=timer_start,
                        timer_end=timer_end
                    )
                    session.add(user_timer)

                await session.commit()
        except Exception as e:
            logging.error(f"Ошибка обновления таймера пользователя {tg_id}: {e}")


async def get_martingale_step(tg_id):
    async with async_session() as session:
        result = await session.execute(select(UMS).where(UMS.tg_id == tg_id))
        user_settings = result.scalars().first()
        return user_settings.martingale_step


async def update_martingale_step(tg_id, step):
    async with async_session() as session:
        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_step=step))

        await session.commit()