# -*- mode: python; -*-


from flask_sqlalchemy import SQLAlchemy

# from sqlalchemy.orm import declarative_base

from datetime import datetime
from flask_login import UserMixin

db = SQLAlchemy()
# Base = declarative_base()


def date_time_now():
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


# module_user = db.Table(
#     "ModuleUser",
#     Base.metadata,
#     db.Column("ModuleId", db.String, db.ForeignKey("Module.Name"), primary_key=True),
#     db.Column("UserId", db.Integer, db.ForeignKey("User.UserId"), primary_key=True),
# )

# association_table = db.Table('association', Base.metadata,
#                              db.Column('left_id', db.ForeignKey('left.id'), primary_key=True),
#                              db.Column('right_id', db.ForeignKey('right.id'), primary_key=True),
# )

# class Parent(Base):
#     __tablename__ = 'left'
#     id = db.Column(db.Integer, primary_key=True)
#     children = db.relationship(
#         "Child",
#         secondary=association_table,
#         back_populates="parents")

# class Child(Base):
#     __tablename__ = 'right'
#     id = db.Column(db.Integer, primary_key=True)
#     parents = db.relationship(
#         "Parent",
#         secondary=association_table,
#         back_populates="children")


class Module(db.Model):
    __tablename__ = "Module"
    name = db.Column("Name", db.String(20), nullable=False, primary_key=True)
    description = db.Column("Description", db.String(50), nullable=False)
    # users = db.relationship("User", secondary=module_user, backref="modules")

    def __repr__(self):
        return f"<Module {self.name}>"


class User(UserMixin, db.Model):
    """UserMixin inheritance required for features described here:

    https://stackoverflow.com/questions/63231163/what-is-the-usermixin-in-flask"""

    __tablename__ = "User"

    def get_id(self):
        return self.primary_key

    primary_key = db.Column("UserId", db.Integer, primary_key=True)
    username = db.Column("Username", db.String(20), nullable=False)
    hashed_password = db.Column("HashedPassword", db.String(100), nullable=False)
    name_first = db.Column("NameFirst", db.String(20), nullable=False)
    name_last = db.Column("NameLast", db.String(20), nullable=False)
    email = db.Column("Email", db.String(20), nullable=False)
    phone_mobile = db.Column("PhoneMobile", db.Integer)
    phone_alternative = db.Column("PhoneAlternative", db.Integer)
    date_time_created = db.Column(
        "DateTimeCreated", db.String, server_default=date_time_now()
    )
    date_time_updated = db.Column(
        "DateTimeUpdated", db.String, server_onupdate=date_time_now()
    )
    # modules = db.relationship("Module", secondary=module_user, backref="users")

    def __repr__(self):
        return f"<User {self.name_first} {self.name_last}>"


class Customer(db.Model):
    """One customer has many invoices and orders associated."""

    __tablename__ = "Customer"
    primary_key = db.Column("CustomerId", db.Integer, nullable=False, primary_key=True)
    name = db.Column("Name", db.String(20), nullable=False)
    name_alternative = db.Column("NameAlternative", db.String(20))
    code_customer = db.Column("CodeCustomer", db.String(20), unique=True)
    code_accounting = db.Column("CodeAccounting", db.String(20), unique=True)
    address = db.Column("Address", db.String(20))
    postal_code = db.Column("PostalCode", db.Integer)
    city = db.Column("City", db.String(20))
    country = db.Column("Country", db.String(20))
    phone = db.Column("Phone", db.String(20))
    website = db.Column("Website", db.String(20))
    email = db.Column("Email", db.String(20))
    professional_id_1 = db.Column("ProfessionalId1", db.String(20), unique=True)
    professional_id_2 = db.Column("ProfessionalId2", db.String(20), unique=True)
    tax_id = db.Column("TaxId", db.String(20), unique=True)
    payment_terms = db.Column("PaymentTerms", db.String(20))
    date_time_created = db.Column(
        "DateTimeCreated", db.String, server_default=date_time_now()
    )
    date_time_updated = db.Column(
        "DateTimeUpdated", db.String, server_onupdate=date_time_now()
    )
    invoices = db.relationship("Invoice", back_populates="customer")
    orders = db.relationship("Order", back_populates="customer")

    def __init__(
            self,
            name,
            name_alternative,
            code_customer,
            code_accounting,
            address,
            postal_code,
            city,
            country,
            phone,
            website,
            email,
            professional_id_1,
            professional_id_2,
            tax_id,
            payment_terms,
    ):
        self.name = name
        self.name_alternative = name_alternative
        self.code_customer = code_customer
        self.code_accounting = code_accounting
        self.address = address
        self.postal_code = postal_code
        self.city = city
        self.country = country
        self.phone = phone
        self.website = website
        self.email = email
        self.professional_id_1 = professional_id_1
        self.professional_id_2 = professional_id_2
        self.tax_id = tax_id
        self.payment_terms = payment_terms

    def __repr__(self):
        return f"<Customer {self.name}>"


class Invoice(db.Model):
    """One invoice has many orders, one customer associated."""

    __tablename__ = "Invoice"
    primary_key = db.Column("InvoiceId", db.Integer, primary_key=True)
    invoice_id_alt = db.Column("InvoiceIdAlt", db.String)
    customer_reference = db.Column("CustomerReference", db.String)
    date_billed = db.Column("DateBilled", db.String)
    date_due = db.Column("DateDue", db.String)
    amount_net = db.Column("AmountNet", db.String)
    amount_gross = db.Column("AmountGross", db.String)
    amount_tax = db.Column("AmountTax", db.String)
    date_time_created = db.Column(
        "DateTimeCreated", db.String, server_default=date_time_now()
    )
    customer_id = db.Column(
        "CustomerId", db.Integer, db.ForeignKey("Customer.CustomerId")
    )
    customer = db.relationship(
        "Customer", back_populates="invoices", foreign_keys=[customer_id]
    )
    orders = db.relationship("Order", back_populates="invoice")

    def __init__(
            self,
            invoice_id_alt,
            customer_id,
            customer_reference,
            date_billed,
            date_due,
            amount_net,
            amount_gross,
            amount_tax,
    ):
        self.invoice_id_alt = invoice_id_alt
        self.customer_id = customer_id
        self.customer_reference = customer_reference
        self.date_billed = date_billed
        self.date_due = date_due
        self.amount_net = amount_net
        self.amount_gross = amount_gross
        self.amount_tax = amount_tax

    def __repr__(self):
        return f"<Invoice for {self.customer.name} billed {self.date_billed}>"


class Order(db.Model):  # TODO
    """One order per line item in invoice."""

    __tablename__ = "Order"
    primary_key = db.Column("OrderId", db.Integer, primary_key=True)
    order_id_alt = db.Column("OrderIdAlt", db.String)
    delivery_date = db.Column("DateDelivery", db.String(20), nullable=False)
    date_time_created = db.Column(
        "DateTimeCreated", db.String, server_default=date_time_now()
    )
    date_time_updated = db.Column(
        "DateTimeUpdated", db.String, server_onupdate=date_time_now()
    )
    customer_id = db.Column(
        "CustomerId",
        db.Integer,
        db.ForeignKey("Customer.CustomerId"),
        nullable=False,
    )
    product_id = db.Column(
        "ProductId",
        db.Integer,
        db.ForeignKey("Product.ProductId"),
        nullable=False,
    )
    invoice_id = db.Column(
        "InvoiceId",
        db.Integer,
        db.ForeignKey("Invoice.InvoiceId"),
        nullable=True,
    )
    customer = db.relationship("Customer", back_populates="orders")
    product = db.relationship("Product", back_populates="orders")
    invoice = db.relationship("Invoice", back_populates="orders")

    def __repr__(self):
        return f"<Order {self.name} at {self.date_time_created}>"


class Product(db.Model):
    __tablename__ = "Product"
    primary_key = db.Column("ProductId", db.Integer, primary_key=True)
    name = db.Column("Name", db.String(20), nullable=False, unique=True)
    code_accounting = db.Column("CodeAccounting", db.String(20))
    unit_weight = db.Column("UnitWeight", db.Float)
    price_net = db.Column("PriceNet", db.Float)
    price_gross = db.Column("PriceGross", db.Float)
    tax_rate = db.Column("TaxRate", db.Float)
    date_time_created = db.Column(
        "DateTimeCreated", db.String, server_default=date_time_now()
    )
    date_time_updated = db.Column(
        "DateTimeUpdated", db.String, server_onupdate=date_time_now()
    )
    # order_id = db.Column("ProductId", db.Integer, db.ForeignKey("Product.ProductId"))
    orders = db.relationship("Order", back_populates="product")

    def __init__(
            self,
            name,
            code_accounting,
            unit_weight,
            price_net,
            price_gross,
            tax_rate,
    ):
        self.name = name
        self.code_accounting = code_accounting
        self.unit_weight = unit_weight
        self.price_net = price_net
        self.price_gross = price_gross
        self.tax_rate = tax_rate

    def __repr__(self):
        return f"<Product {self.name}>"


class FertiLog(db.Model):
    __tablename__ = "FertiLog"
    primary_key = db.Column("FertiLogId", db.Integer, primary_key=True)
    nno3 = db.Column("NNO3", db.Float, default=0)
    p = db.Column("P", db.Float, default=0)
    k = db.Column("K", db.Float, default=0)
    ca = db.Column("Ca", db.Float, default=0)
    mg = db.Column("Mg", db.Float, default=0)
    s = db.Column("S", db.Float, default=0)
    na = db.Column("Na", db.Float, default=0)
    cl = db.Column("Cl", db.Float, default=0)
    fe = db.Column("Fe", db.Float, default=0)
    zn = db.Column("Zn", db.Float, default=0)
    b = db.Column("B", db.Float, default=0)
    mn = db.Column("Mn", db.Float, default=0)
    cu = db.Column("Cu", db.Float, default=0)
    mo = db.Column("Mo", db.Float, default=0)
    si = db.Column("Si", db.Float, default=0)
    nnh4 = db.Column("NNH4", db.Float, default=0)
    date_time_created = db.Column(
        "DateTimeCreated", db.String, server_default=date_time_now()
    )
    date_time_updated = db.Column(
        "DateTimeUpdated", db.String, server_onupdate=date_time_now()
    )
    targets = db.relationship("FertiTarget", back_populates="ferti_log")

    def __init__(self, nno3, p, k, ca, mg, s, na, cl, fe, zn, b, mn, cu, mo, si, nnh4):
        self.nno3 = nno3
        self.p = p
        self.k = k
        self.ca = ca
        self.mg = mg
        self.s = s
        self.na = na
        self.cl = cl
        self.fe = fe
        self.zn = zn
        self.b = b
        self.mn = mn
        self.cu = cu
        self.mo = mo
        self.si = si
        self.nnh4 = nnh4

    def __repr__(self):
        return f"<Log ID {self.primary_key}>"


class FertiTarget(FertiLog):
    __tablename__ = "FertiTarget"
    primary_key = db.Column("FertiTargetId", db.Integer, primary_key=True)
    ferti_log_id = db.Column(
        "FertiLogId", db.Integer, db.ForeignKey("FertiLog.FertiLogId")
    )
    ferti_log = db.relationship("FertiLog", back_populates="targets")

    # def __init__(self):
    #     super(*args).__init__()

    def __repr__(self):
        return f"<Target ID {self.primary_key}>"