# crud.py

from datetime import datetime

from sqlalchemy.orm import Session

from . import models, schemas


def get_price(db: Session, price_id: int):
    return db.query(models.Price).filter(models.Price.id == price_id).first()


def get_price_by_name(db: Session, name: str):
    return db.query(models.Price).filter(models.Price.name == name).first()


def update_price(db: Session, item: schemas.PriceCreate, price_id: int):
    db_item = get_price(db, price_id=price_id)
    db_item.name = item.name
    db_item.price = item.price
    db.add(db_item)
    db.commit()
    db.refresh(db_item)
    return db_item


def delete_price(db: Session, price_id: int):
    db_item = get_price(db, price_id=price_id)
    db.delete(db_item)
    db.commit()
    db.refresh(db_item)
    return db_item


def get_prices(db: Session, skip: int = 0, limit: int = 100):
    return db.query(models.Price).offset(skip).limit(limit).all()


def create_price(db: Session, item: schemas.PriceCreate):
    db_price = models.Price(
        name=item.name,
        price=item.price,
        datetime=datetime.now()
    )
    db.add(db_price)
    db.commit()
    db.refresh(db_price)
    return db_price


# database.py

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./db_price.sqlite"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()


# main.py

import asyncio
from typing import List

from fastapi import Depends, FastAPI, HTTPException
from sqlalchemy.orm import Session

from . import crud, models, schemas
from .database import SessionLocal, engine

from rocketry import Rocketry

from app.db.session import db

from .price_parser import start_parser


app_rocketry = Rocketry(execution="async")


@app_rocketry.task('every 15 seconds')
async def do_things():
    print('Parser is started')

    name, price = start_parser()

    import requests

    def blocking_task():
        print('Test')

        print(name, price)

        headers = {
            'accept': 'application/json',
            'Content-Type': 'application/json',
        }

        json_data = {
            'name': name,
            'price': price,
        }

        response = requests.post(
            'http://127.0.0.1:8000/prices/create', headers=headers, json=json_data
        )

        print(response, json_data)

    loop = asyncio.get_running_loop()
    loop.run_in_executor(None, blocking_task)


models.Base.metadata.create_all(bind=engine)

app = FastAPI()


def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()


@app.on_event("startup")
async def startup_event():

    @app.on_event("startup")
    async def startup():
        await db.connect()

    @app.on_event("shutdown")
    async def startup():
        await db.disconnect()

    asyncio.create_task(app_rocketry.serve())


@app.get("/prices", response_model=List[schemas.Price])
def read_prices(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    prices = crud.get_prices(db, skip=skip, limit=limit)
    return prices


@app.get("/prices/{price_id}", response_model=schemas.Price)
def read_price(price_id: int, db: Session = Depends(get_db)):
    db_price = crud.get_price(db, price_id=price_id)
    if db_price is None:
        raise HTTPException(status_code=404, detail="This record is missing")
    return db_price


@app.post("/prices/create", response_model=schemas.Price)
def create_price(item: schemas.PriceCreate, db: Session = Depends(get_db)):
    db_price = crud.get_price_by_name(db, name=item.name)
    if db_price and db_price.price == item.price:
        raise HTTPException(status_code=400, detail="The table contains this name")
    return crud.create_price(db=db, item=item)


@app.put("/prices/{price_id}", response_model=schemas.Price)
def update_price(price_id: int, item: schemas.PriceCreate, db: Session = Depends(get_db)):
    db_price = crud.get_price(db, price_id=price_id)
    if not db_price:
        raise HTTPException(status_code=404, detail="This record is missing")
    return crud.update_price(db=db, item=item, price_id=price_id)


@app.delete("/prices/{price_id}", response_model=dict)
def delete_price(price_id: int, db: Session = Depends(get_db)):
    db_price = crud.get_price(db, price_id=price_id)
    if not db_price:
        raise HTTPException(status_code=404, detail="This record is missing")
    crud.delete_price(db=db, price_id=price_id)
    return {"status": "ok"}



# models.py

from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, DateTime
from sqlalchemy.orm import relationship

from .database import Base


class Price(Base):
    __tablename__ = "prices"

    id = Column(Integer, primary_key=True)
    name = Column(String)
    price = Column(Integer)
    datetime = Column(DateTime)



# price_parser.py

import requests
from bs4 import BeautifulSoup as bs
from sqlalchemy.orm import declarative_base

Base = declarative_base()

PRODUCT_URL = 'https://ekaterinburg.lifemebel.ru/catalog/stoly/dlya_komnat/servirovochnye/' \
              'model/cervirovochnyy_stol_trolly_oak/'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 '
                  'YaBrowser/23.7.0.2526 Yowser/2.5 Safari/537.36',
    'Cookie': 'FTID=2oBjMf1U4C2J:1690619148:3245294:::; path=/; expires=Mon, 29-Jul-24 08:25:48 GMT; domain=.mail.ru; '
              'HttpOnly; SameSite=None; Secure'
}


def start_parser():
    page = requests.get(url=PRODUCT_URL, headers=headers)
    html = page.text

    soup = bs(html, 'lxml')
    title = soup.find('div', class_='new-product-title').find('h2', itemprop="name")
    title = title.get_text().strip()

    price = soup.find('div', class_='nowrap new-product-price-new')
    price = int(price.get_text().strip()[:-5])

    return title, price


start_parser()



# schemas.py

from typing import List, Union
from pydantic import BaseModel
from datetime import datetime


class PriceBase(BaseModel):
    name: str
    price: int


class PriceCreate(PriceBase):
    pass


class Price(PriceBase):
    id: int
    datetime: datetime

    class Config:
        orm_mode = True