from flask import request, jsonify
from flask_login import current_user, login_required
from app.service import service
from app import db
from datetime import datetime

from app.classes.auth import Auth_User
from app.classes.customer import Customer_Customer
from app.classes.service import (Service_Call,
                                 Service_Call_schema,
                                 Service_Call_Notes_Dispatcher,
                                 Service_Call_Notes_Technician,
                                 Service_Call_Notes_Dispatcher_schema,
                                 )
from app.classes.cards import Card_Card
from app.classes.employee import Employee_Employee


@service.route("/<string:service_id>", methods=["GET"])
@login_required
def get_specific_service_call(service_id):

    service_call = db.session \
        .query(Service_Call) \
        .filter(Service_Call.id == service_id) \
        .first()

    service_schema = Service_Call_schema(many=False)
    return jsonify(service_schema.dump(service_call))


@service.route("/paymenttype/<int:service_id>/<int:type_of_payment>", methods=["PUT"])
def update_a_service_payment(service_id, type_of_payment):
    """
    This update  a delivery for example if user updates to a fill
    """

    service_call = (db.session
        .query(Service_Call)
        .filter(Service_Call.id == service_id)
        .first())

    service_call.payment_type = type_of_payment

    db.session.add(service_call)
    db.session.commit()

    return jsonify({"ok": True}), 200


@service.route("/call/notes/<string:service_id>", methods=["GET"])
@login_required
def get_service_notes_call(service_id):
    service_call = db.session \
        .query(Service_Call_Notes_Dispatcher) \
        .filter(Service_Call_Notes_Dispatcher.service_call_id == service_id) \
        .first()

    service_schema = Service_Call_Notes_Dispatcher_schema(many=False)
    return jsonify(service_schema.dump(service_call))


@service.route("/all", methods=["GET"])
def service_view_all():
    """
    Get all service calls
    """

    service_calls = db.session \
        .query(Service_Call) \
        .filter(Service_Call.completed == 0) \
        .order_by(Service_Call.when_called.desc()) \
        .all()

    customer_schema = Service_Call_schema(many=True)
    return jsonify(customer_schema.dump(service_calls))


@service.route("/all/<int:page>", methods=["GET"])
def service_view(page):
    """
    Get all service calls
    """
    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

    service_calls = db.session \
        .query(Service_Call) \
        .filter(Service_Call.completed == 0) \
        .order_by(Service_Call.when_called.desc()) \
        .limit(per_page_amount).offset(offset_limit)

    customer_schema = Service_Call_schema(many=True)
    return jsonify(customer_schema.dump(service_calls))


@service.route("/customer/<int:customer_id>/<int:page>", methods=["GET"])
def service_customer_view(customer_id, page):
    """
    Get all service calls
    """
    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

    service_calls = db.session \
        .query(Service_Call) \
        .filter(Service_Call.customer_id == customer_id) \
        .order_by(Service_Call.id.desc()) \
        .limit(per_page_amount).offset(offset_limit)

    customer_schema = Service_Call_schema(many=True)
    return jsonify(customer_schema.dump(service_calls))


@service.route("/create/<int:user_id>", methods=["POST"])
def service_create_call(user_id):
    """
    create a service call
    """

    now = datetime.utcnow()
    get_customer = db.session \
        .query(Customer_Customer) \
        .filter(Customer_Customer.id == user_id) \
        .first()
    print(request.json)
    get_service_type = request.json["type_of_service"]
    service_note = request.json["dispatcher_notes_taken"]
    service_subject = request.json["dispatcher_subject_taken"]
    scheduled_date_date = request.json["date_scheduled"]
    dispatcher_id = request.json["dispatcher_id"]

    card_payment = request.json["credit"]
    cash_payment = request.json["cash"]
    try:
        if request.json["credit_card_id"]:
            card_payment_id = request.json["credit_card_id"]
        else:
            card_payment_id = None
    except:
        card_payment_id = None

    if cash_payment is True and card_payment is False:
        delivery_payment_method = 0
    elif card_payment is True and cash_payment is False:
        delivery_payment_method = 1

    elif card_payment is True and cash_payment is True:
        delivery_payment_method = 2
    else:
        delivery_payment_method = 3

    if card_payment_id is not None:
        get_card = (db.session
                    .query(Card_Card)
                    .filter(Card_Card.id == card_payment_id)
                    .filter(Card_Card.user_id == get_customer.id)
                    .first())
        card_id_from_customer = get_card.id
    else:
        card_id_from_customer = None

    date_object = datetime.strptime(scheduled_date_date, '%Y-%m-%d').date()

    get_tech = (db.session
                .query(Employee_Employee)
                .first())

    create_a_call = Service_Call(
        customer_id=get_customer.id,
        customer_last_name=get_customer.customer_last_name,
        customer_first_name=get_customer.customer_first_name,
        customer_town=get_customer.customer_town,
        customer_state=get_customer.customer_state,
        customer_zip=get_customer.customer_zip,
        customer_apt=get_customer.customer_apt,
        customer_address=get_customer.customer_address,
        status=0,
        service_type=get_service_type,
        when_called=now,
        scheduled_date=date_object,
        when_serviced=None,
        tech_id=get_tech.id,
        tech_first_name=get_tech.employee_first_name,
        tech_last_name=get_tech.employee_last_name,
        completed=0,
        payment_type=delivery_payment_method,
        payment_card_id=card_id_from_customer,
    )

    db.session.add(create_a_call)
    db.session.flush()

    create_new_note = Service_Call_Notes_Dispatcher(
        service_call_id=create_a_call.id,
        dispatcher_subject=service_subject,
        dispatcher_notes=service_note,
        time_added=now,
        dispatcher_id=dispatcher_id,
        dispatcher_name=None,
    )

    db.session.add(create_new_note)
    db.session.commit()

    db.session.commit()

    return jsonify({"ok": True,
                    'user_id': get_customer.id,
                    'service_id': create_a_call.id,
                    }), 200

@service.route("/delete/<int:service_id>", methods=["DELETE"])
def service_delete_call(service_id):
    """
    delete a service call
    """
    get_call_to_delete = (db.session
                          .query(Service_Call)
                          .filter(Service_Call.id == service_id)
                          .first())
    db.session.delete(get_call_to_delete)
    db.session.commit()

    return jsonify({"ok": True}), 200



@service.route("/edit/<int:service_id>", methods=["PUT"])
def service_edit_call(service_id):
    """
    Update a service call
    """

    get_service_type = request.json["type_of_service"]
    scheduled_date_date = request.json["date_scheduled"]
    dispatcher_subject_taken = request.json["dispatcher_subject_taken"]
    dispatcher_notes_taken = request.json["dispatcher_notes_taken"]
    tech_id = request.json["tech_id"]

    card_payment = request.json["credit"]
    cash_payment = request.json["cash"]

    if request.json["credit_card_id"]:
        card_payment_id = request.json["credit_card_id"]
    else:
        card_payment_id = None

    get_tech = db.session \
        .query(Employee_Employee) \
        .filter(Employee_Employee.id == tech_id) \
        .first()

    get_service_call_call = db.session \
        .query(Service_Call) \
        .filter(Service_Call.id == service_id) \
        .first()

    if card_payment_id is not None:
        get_customer = db.session \
            .query(Customer_Customer) \
            .filter(Customer_Customer.id == get_service_call_call.customer_id) \
            .first()

        get_card = (db.session
                    .query(Card_Card)
                    .filter(Card_Card.id == card_payment_id)
                    .filter(Card_Card.user_id == get_customer.id)
                    .first())
        card_id_from_customer = get_card.id
    else:
        card_id_from_customer = None

    if cash_payment is True and card_payment is False:
        delivery_payment_method = 0
    elif card_payment is True and cash_payment is False:
        delivery_payment_method = 1

    elif card_payment is True and cash_payment is True:
        delivery_payment_method = 2
    else:
        delivery_payment_method = 3

    get_service_call_notes = (db.session
                              .query(Service_Call_Notes_Dispatcher)
                              .filter(Service_Call_Notes_Dispatcher.service_call_id == get_service_call_call.id)
                              .first())

    get_service_call_notes.dispatcher_subject = dispatcher_subject_taken
    get_service_call_notes.dispatcher_notes = dispatcher_notes_taken

    get_service_call_call.service_type = get_service_type
    get_service_call_call.scheduled_date = scheduled_date_date
    get_service_call_call.tech_id = get_tech.id
    get_service_call_call.payment_type = delivery_payment_method
    get_service_call_call.payment_card_id = card_id_from_customer

    db.session.add(get_service_call_call)
    db.session.commit()

    return jsonify({"ok": True}), 200


@service.route("/update/type/<int:service_id>", methods=["PUT"])
def service_update_service_type(service_id):
    """
    Update a service call diagnosis
    """
    get_service_type = request.json["service_type"]

    get_service_call = db.session \
        .query(Service_Call) \
        .filter(Service_Call.service_id == service_id) \
        .first()

    get_service_call.service_type = get_service_type

    db.session.add(get_service_call)
    db.session.commit()

    return jsonify({"ok": True}), 200


@service.route("/note/dispatcher/<int:service_id>", methods=["PUT"])
def service_create_note_dispatcher(service_id):
    """
    Initial dispatcher note about the call
    """

    service_note = request.json["dispatcher_text"]
    now = datetime.utcnow()

    user = db.session \
        .query(Auth_User) \
        .filter(Auth_User.id == current_user.id) \
        .first()

    get_service_call_order = db.session \
        .query(Service_Call) \
        .filter(Service_Call.service_id == service_id) \
        .first()

    create_new_note = Service_Call_Notes_Dispatcher(
        service_call_id=get_service_call_order.id,
        dispatcher_notes=service_note,
        time_added=now,
        dispatcher_id=user.id,
        dispatcher_name=user.username,
    )

    db.session.add(create_new_note)
    db.session.commit()

    return jsonify({"ok": True}), 200


@service.route("/note/technician/<int:service_id>", methods=["PUT"])
def service_create_note_technician(service_id):
    """
    Technician can create notes on the call
    """

    service_technician_notes = request.json["technician_comments"]
    now = datetime.utcnow()

    user = db.session \
        .query(Auth_User) \
        .filter(Auth_User.id == current_user.id) \
        .first()

    get_service_call = db.session \
        .query(Service_Call) \
        .filter(Service_Call.service_id == service_id) \
        .first()

    create_new_note = Service_Call_Notes_Technician(
        service_call_id=get_service_call.id,
        technician_comments=service_technician_notes,
        time_added=now,
        technician_id=user.id,
        technician_name=user.username,
    )

    db.session.add(create_new_note)
    db.session.commit()

    return jsonify({"ok": True}), 200