import logging
from typing import Any

logger = logging.getLogger(__name__)

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

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("Новый пользователь был добавлен в бд")

        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,
            ))

            logger.info(f"Bybit был успешно подключен")

        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 был успешно добавлен")

        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("Основные настройки нового пользователя были заполнены")

        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("Риск-Менеджмент настройки нового пользователя были заполнены")

        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("Условные настройки нового пользователя были заполнены")

        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("Дополнительные настройки нового пользователя были заполнены")

        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_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("Получение основных настроек пользователя")

            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("Получение риск-менеджмента настроек пользователя")

            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("Изменен трейд мод")
            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("Изменен тип маржи")
            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 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()