import os
import logging
from sqlalchemy import  Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine, MetaData
from sqlalchemy.orm import sessionmaker
import config


Base = declarative_base()

def error_return_beforeID(fn):
    def aux(*args, **kwargs):
        try:
            fn(*args, **kwargs)
        except Exception as e:
            return 1
    return aux

def error_in_set_to_base(fn):
    def aux(*args, **kwargs):
        try:
            fn(*args, **kwargs)
        except Exception as e:
            logging.error(e)
    return aux

class dataBase():
    class Admins(Base):
        __tablename__ = 'admins'

        id = Column(Integer, primary_key=True)
        login = Column(String)

        def __repr__(self):
            return "<Admins (id = %s, login='%s')>" % (self.id, self.login)

    class News(Base):
        __tablename__ = 'news'

        id = Column(Integer, primary_key=True)
        link = Column(String)
        text = Column(String)
        call = Column(Integer)

        def __repr__(self):
            return "<News (id = %s, link='%s', text = '%s', call = '%s')>" \
                   % (self.id, self.link,self.text, self.call)

    def __init__(self, object_queue_news):
        self.connect = create_engine('sqlite:///'+os.path.abspath(os.curdir)+config.link_db, echo=True)
        self.meta = MetaData()
        self.Session = sessionmaker(bind=self.connect)
        self.object_queue_news = object_queue_news

    def getAdmins(self):
        session = self.Session()
        word = session.query(self.Admins).first()
        session.close()

    @error_return_beforeID
    def return_beforeID(self, session):
        beforeID = session.query(self.News).order_by(self.News.id.desc()).first()
        beforeID = beforeID.id + 1
        return beforeID

    def get_before_id(self):
        self.meta.clear()
        session = self.Session()
        beforeID = self.return_beforeID(session)
        session.close()
        return beforeID

    def set_news(self,dict_):
        self.meta.clear()
        for key in dict_:
                beforeID = self.get_before_id()
                session = self.Session()
                self.set_news_to_base(dict_, key, session, beforeID)
                session.close()

    @error_in_set_to_base
    def set_news_to_base(self, dict_, key, session, beforeID):
        insert = self.News(id=beforeID, link=dict_[key], text=key, call=0)
        session.add(insert)
        session.commit()


    def from_queue_to_database(self):
        while True:
            try:
                self.set_news(self.object_queue_news.dequeue())
            except:
                break