import logging
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_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_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_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

# UPDATE_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()