import logging
logger = logging.getLogger(__name__)

from sqlalchemy import BigInteger, Boolean, Integer, String, ForeignKey
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy.ext.asyncio import AsyncAttrs, async_sessionmaker, create_async_engine

from sqlalchemy import select, insert

engine = create_async_engine(url='sqlite+aiosqlite:///db.sqlite3')

async_session = async_sessionmaker(engine)

class Base(AsyncAttrs, DeclarativeBase):
    pass

class User_Telegram_Id(Base):
    __tablename__ = 'user_telegram_id'

    id: Mapped[int] = mapped_column(primary_key=True)

    tg_id = mapped_column(BigInteger)

class Trading_Mode(Base):
    __tablename__ = 'trading_modes'

    id: Mapped[int] = mapped_column(primary_key=True)

    mode = mapped_column(String(10), unique=True)

class Margin_type(Base):
    __tablename__ = 'margin_types'

    id: Mapped[int] = mapped_column(primary_key=True)

    type = mapped_column(String(15), unique=True)

class Trigger(Base):
    __tablename__ = 'triggers'

    id: Mapped[int] = mapped_column(primary_key=True)

    trigger = mapped_column(String(15), unique=True)

class User_Main_Settings(Base):
    __tablename__ = 'user_main_settings'

    id: Mapped[int] = mapped_column(primary_key=True)

    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))

    trading_mode = mapped_column(ForeignKey("trading_modes.mode"))
    margin_type = mapped_column(ForeignKey("margin_types.type"))
    size_leverage = mapped_column(Integer(), default=1)
    starting_quantity = mapped_column(Integer(), default=1)
    martingale_factor = mapped_column(Integer(), default=1)
    maximal_quantity = mapped_column(Integer(), default=10)

class User_Risk_Management_Settings(Base):
    __tablename__ = 'user_risk_management_settings'

    id: Mapped[int] = mapped_column(primary_key=True)

    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))

    price_profit = mapped_column(Integer(), default=1)
    price_loss = mapped_column(Integer(), default=1)
    max_risk_deal = mapped_column(Integer(), default=1)

class User_Condition_Settings(Base):
    __tablename__ = 'user_condition_settings'

    id: Mapped[int] = mapped_column(primary_key=True)

    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))

    trigger = mapped_column(ForeignKey("triggers.trigger"))
    filter_time = mapped_column(String(25), default='???')
    filter_volatility = mapped_column(Boolean, default=False)
    external_cues = mapped_column(Boolean, default=False)
    tradingview_cues = mapped_column(Boolean, default=False)
    webhook = mapped_column(String(40), default='')
    ai_analytics = mapped_column(Boolean, default=False)

class User_Additional_Settings(Base):
    __tablename__ = 'user_additional_settings'

    id: Mapped[int] = mapped_column(primary_key=True)

    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))

    pattern_save = mapped_column(Boolean, default=False)
    autostart = mapped_column(Boolean, default=False)
    notifications = mapped_column(Boolean, default=False)

async def async_main():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
                                                                  
        # Заполнение таблиц
        modes = ['Long', 'Short', 'Switch', 'Smart']
        for mode in modes:
            result = await conn.execute(select(Trading_Mode).where(Trading_Mode.mode == mode))
            if not result.first():
                logger.info("Заполение таблицы режима торговли")
                await conn.execute(Trading_Mode.__table__.insert().values(mode=mode))

        types = ['Изолированный', 'Кросс']
        for type in types:
            result = await conn.execute(select(Margin_type).where(Margin_type.type == type))           
            if not result.first():
                logger.info("Заполение таблицы типов маржи")
                await conn.execute(Margin_type.__table__.insert().values(type=type))

        triggers = ['Ручной', 'Автоматический', 'TradingView']
        for trigger in triggers:
            result = await conn.execute(select(Trigger).where(Trigger.trigger == trigger))
            if not result.first():
                logger.info("Заполение таблицы триггеров")
                await conn.execute(Trigger.__table__.insert().values(trigger=trigger))