import logging
from flask import request

from sqlalchemy import or_

from flask_login import login_required
from app.employees import employees
from app import db
from app.common.responses import success_response
from app.classes.employee import Employee_Employee, Employee_Employee_schema
from app.classes.auth import Auth_User
from app.classes.stats_employee import Stats_Employee_Oil, Stats_Employee_Office

logger = logging.getLogger(__name__)

@employees.route("/<int:userid>", methods=["GET"])
@login_required
def get_specific_employee(userid):
    logger.info(f"GET /employees/{userid} - Fetching employee by user ID")
    employee = db.session \
        .query(Employee_Employee) \
        .filter(Employee_Employee.user_id == userid) \
        .first()

    # Get active status from Auth_User
    user = db.session.query(Auth_User).filter(Auth_User.id == userid).first()
    active_status = user.active if user else 1

    employee_schema = Employee_Employee_schema(many=False)
    employee_data = employee_schema.dump(employee)
    employee_data['active'] = active_status

    return success_response({"employee": employee_data})


@employees.route("/byid/<int:employee_id>", methods=["GET"])
@login_required
def get_employee_by_id(employee_id):
    logger.info(f"GET /employees/byid/{employee_id} - Fetching employee by ID")
    employee = db.session \
        .query(Employee_Employee) \
        .filter(Employee_Employee.id == employee_id) \
        .first()
    employee_schema = Employee_Employee_schema(many=False)
    return success_response({"employee": employee_schema.dump(employee)})


@employees.route("/userid/<int:userid>", methods=["GET"])
@login_required
def get_specific_employee_user_id(userid):
    logger.info(f"GET /employees/userid/{userid} - Fetching employee by user ID")
    employee = db.session \
        .query(Employee_Employee) \
        .filter(Employee_Employee.user_id == userid) \
        .first()
    employee_schema = Employee_Employee_schema(many=False)
    return success_response({"employee": employee_schema.dump(employee)})


@employees.route("/all/<int:page>", methods=["GET"])
@login_required
def all_employees_paginated(page):
    """
    pagination all employees
    """
    logger.info(f"GET /employees/all/{page} - Fetching employees page {page}")
    per_page_amount = 50
    if page is None:
        offset_limit = 0
    elif page == 1:
        offset_limit = 0
    else:
        offset_limit = (per_page_amount * page) - per_page_amount

    employee_list = (db.session
                     .query(Employee_Employee) \
                     .limit(per_page_amount).offset(offset_limit))

    employee_schema = Employee_Employee_schema(many=True)
    return success_response({"employees": employee_schema.dump(employee_list)})


@employees.route("/all", methods=["GET"])
@login_required
def all_employees():
    logger.info("GET /employees/all - Fetching all employees")
    employee_list = db.session \
        .query(Employee_Employee) \
        .all()
    customer_schema = Employee_Employee_schema(many=True)
    return success_response({"employees": customer_schema.dump(employee_list)})


@employees.route("/drivers", methods=["GET"])
@login_required
def all_employees_drivers():
    logger.info("GET /employees/drivers - Fetching all drivers")
    employee_list = db.session \
        .query(Employee_Employee) \
        .filter(or_(Employee_Employee.employee_type == 4,
                    Employee_Employee.employee_type == 8)) \
        .all()

    customer_schema = Employee_Employee_schema(many=True)
    return success_response({"drivers": customer_schema.dump(employee_list)})


@employees.route("/techs", methods=["GET"])
@login_required
def all_employees_techs():
    logger.info("GET /employees/techs - Fetching all technicians")
    employee_list = db.session \
        .query(Employee_Employee) \
        .filter(or_(Employee_Employee.employee_type == 0,
                    Employee_Employee.employee_type == 1,
                    Employee_Employee.employee_type == 5,
                    Employee_Employee.employee_type == 8,
                    )) \
        .all()
    customer_schema = Employee_Employee_schema(many=True)
    return success_response({"techs": customer_schema.dump(employee_list)})


@employees.route("/create", methods=["POST"])
@login_required
def employee_create():
    """
    This will create an employee
    """
    logger.info("POST /employees/create - Creating new employee")
    e_last_name = request.json["employee_last_name"]
    e_first_name = request.json["employee_first_name"]
    e_town = request.json["employee_town"]
    e_state = request.json["employee_state"]
    e_address = request.json["employee_address"]
    e_zip = request.json["employee_zip"]
    e_birthday = request.json["employee_birthday"]
    e_type = request.json["employee_type"]
    e_start_date = request.json["employee_start_date"]
    e_end_date = request.json["employee_end_date"]
    e_phone_number = request.json["employee_phone_number"]

    emp_state = int(e_state)
    emp_type = int(e_type)
    emp_zip = int(e_zip)

    if e_end_date == '':
        e_end_date = None

    new_employee = Employee_Employee(

        employee_last_name=e_last_name,
        employee_first_name=e_first_name,
        employee_town=e_town,
        employee_state=emp_state,
        employee_zip=emp_zip,
        employee_address=e_address,
        employee_birthday=e_birthday,
        employee_type=emp_type,
        employee_start_date=e_start_date,
        employee_end_date=e_end_date,
        employee_phone_number=e_phone_number,
    )


    db.session.add(new_employee)
    db.session.flush()
    
    new_stats_office = Stats_Employee_Office(
        employee_id = new_employee.id,
        total_orders = 0,
        total_credit_cards_proccessed = 0,
    )
    db.session.add(new_stats_office)

    new_stats_oil = Stats_Employee_Oil(
        employee_id = new_employee.id,
        total_deliveries = 0,
        total_gallons_delivered = 0,
        total_primes = 0,
        oil_total_profit_delivered = 0,
    )
    db.session.add(new_stats_oil)

    return success_response({'user_id': new_employee.id})


@employees.route("/edit/<int:employee_id>", methods=["POST"])
def employee_edit(employee_id):
    """
    This will update an employee
    """
    logger.info(f"POST /employees/edit/{employee_id} - Editing employee")
    e_last_name = request.json["employee_last_name"]
    e_first_name = request.json["employee_first_name"]
    e_town = request.json["employee_town"]
    e_state = request.json["employee_state"]
    e_zip = request.json["employee_zip"]
    e_birthday = request.json["employee_birthday"]
    e_type = request.json["employee_type"]
    e_start_date = request.json["employee_start_date"]
    e_end_date = request.json["employee_end_date"]
    e_active = request.json.get("active", 1)

    get_employee = db.session \
        .query(Employee_Employee) \
        .filter(Employee_Employee.id == employee_id) \
        .first()

    get_employee.employee_first_name = e_first_name
    get_employee.employee_last_name = e_last_name
    get_employee.employee_town = e_town
    get_employee.employee_state = e_state
    get_employee.employee_zip = e_zip
    get_employee.employee_birthday = e_birthday
    get_employee.employee_type = e_type
    get_employee.employee_start_date = e_start_date
    if e_end_date != 'None':
        get_employee.employee_end_date = e_end_date

    # Update active status in Auth_User
    user = db.session.query(Auth_User).filter(Auth_User.id == get_employee.user_id).first()
    if user:
        user.active = int(e_active)
        db.session.add(user)

    db.session.add(get_employee)
    db.session.commit()

    return success_response()