from flask import request, jsonify
from flask_login import current_user
from datetime import date, datetime, timedelta
from app.delivery import delivery
from app import db
from app.classes.customer import (Customer_Customer,
                                  Customer_Customer_schema)
from app.classes.delivery import (Delivery_Delivery,
                                  Delivery_Delivery_schema,
                                  Delivery_Notes_Driver,
                                  )
from app.classes.employee import Employee_Employee
from app.classes.cards import Card_Card
from app.classes.pricing import Pricing_Oil_Oil
from app.classes.auth import Auth_User


@delivery.route("/<int:delivery_id>", methods=["GET"])
def get_a_delivery(delivery_id):
    """
    """
    get_delivery = db.session\
                .query(Delivery_Delivery)\
                .filter(Delivery_Delivery.id == delivery_id)\
                .first()
  

    return jsonify({
            "ok": True,
            'delivery': {
                'id': get_delivery.id,
                'customer_id': get_delivery.customer_id,
                'delivery_expected_delivery_date': str(get_delivery.expected_delivery_date),
                'delivery_asked_for_fill': get_delivery.customer_asked_for_fill,
                'delivery_gallons_ordered': get_delivery.gallons_ordered,
                'delivery_dispatcher_notes': get_delivery.dispatcher_notes,
                'delivery_prime': get_delivery.prime,
                'delivery_same_day': get_delivery.same_day,
                'when_ordered': get_delivery.when_ordered,
                'customer_price': get_delivery.customer_price,
                'delivery_status': get_delivery.delivery_status,
                'payment_type': get_delivery.payment_type,
                'payment_card_id': get_delivery.payment_card_id,
                'driver_employee_id': get_delivery.driver_employee_id,
                'driver_first_name': get_delivery.driver_first_name,
                'driver_last_name': get_delivery.driver_last_name,
            },
    }), 200

@delivery.route("/past/<int:customer_id>", methods=["GET"])
def get_customer_past_delivery(customer_id):

    get_customer_past_delivery = (db.session
                .query(Delivery_Delivery)
                .filter(Delivery_Delivery.customer_id == customer_id)
                .limit(10))
    
    delivery_schema = Delivery_Delivery_schema(many=True)
    return jsonify(delivery_schema.dump(get_customer_past_delivery))


@delivery.route("/order/<int:delivery_id>", methods=["GET"])
def get_a_specific_delivery(delivery_id):

    get_delivery = db.session\
                .query(Delivery_Delivery)\
                .filter(Delivery_Delivery.id == delivery_id)\
                .first()
    delivery_schema = Delivery_Delivery_schema(many=False)
    return jsonify(delivery_schema.dump(get_delivery))




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

    get_delivery = (db.session
        .query(Delivery_Delivery)
        .filter(Delivery_Delivery.id == delivery_id)
        .first())

    get_delivery.payment_type = type_of_payment

    db.session.add(get_delivery)
    db.session.commit()

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


@delivery.route("/all/<int:page>", methods=["GET"])
def get_deliveries_not_delivered_all(page):
    """
    This will get deliveries not done
    """
    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
        
        
    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.delivery_status != 10) 
        .filter(Delivery_Delivery.delivery_status != 3) 
        .order_by(Delivery_Delivery.id.asc())
        .limit(per_page_amount).offset(offset_limit))


    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))


@delivery.route("/customer/<int:customer_id>/<int:page>", methods=["GET"])
def get_deliveries_from_customer(customer_id, page):
    """
    This will get deliveries not done
    """

    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.customer_id == customer_id)
        .order_by(Delivery_Delivery.id.desc())
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))

@delivery.route("/all/order/<int:page>", methods=["GET"])
def get_deliveries_not_delivered(page):
    
    """
    This will get deliveries not done
    """
    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

    deliveries = (db.session
                        .query(Delivery_Delivery)
                        .filter(Delivery_Delivery.delivery_status == 0)
                        .order_by(Delivery_Delivery.when_ordered.desc())
                        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))

@delivery.route("/waiting/<int:page>", methods=["GET"])
def get_deliveries_waiting(page):
    """
    This will get deliveries not done
    """
    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.delivery_status == 0) 
        .order_by(Delivery_Delivery.when_ordered.desc()) 
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))

@delivery.route("/delivered/<int:page>", methods=["GET"])
def get_deliveries_delivered(page):
    """
    This will get deliveries not done
    """
    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.delivery_status == 1) 
        .order_by(Delivery_Delivery.when_ordered.desc()) 
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))

@delivery.route("/outfordelivery/<int:page>", methods=["GET"])
def get_deliveries_outfordelivery(page):
    """
    This will get deliveries not done
    """
    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.expected_delivery_date == date.today())
        .order_by(Delivery_Delivery.delivery_status.asc()) 
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))



@delivery.route("/tommorrow/<int:page>", methods=["GET"])
def get_deliveries_tommorrow(page):
    """
    This will get deliveries not done
    """
    tomm = date.today() + timedelta(days=1)
    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.expected_delivery_date == tomm)
        .order_by(Delivery_Delivery.when_ordered.desc()) 
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))


@delivery.route("/finalized/<int:page>", methods=["GET"])
def get_deliveries_finalized(page):
    """
    This will get deliveries not done
    """
    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.delivery_status == 10) 
        .order_by(Delivery_Delivery.when_ordered.desc()) 
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))



@delivery.route("/cancelled/<int:page>", methods=["GET"])
def get_deliveries_cancelled(page):
    """
    This will get deliveries not done
    """
    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.delivery_status == 3) 
        .order_by(Delivery_Delivery.when_ordered.desc()) 
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))


@delivery.route("/partialdelivery/<int:page>", methods=["GET"])
def get_deliveries_partial(page):
    """
    This will get deliveries not done
    """
    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.delivery_status == 4) 
        .order_by(Delivery_Delivery.when_ordered.desc()) 
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))

@delivery.route("/issue/<int:page>", methods=["GET"])
def get_deliveries_issue(page):
    """
    This will get deliveries not done
    """
    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

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.delivery_status == 5) 
        .order_by(Delivery_Delivery.when_ordered.desc()) 
        .limit(per_page_amount).offset(offset_limit))

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))


@delivery.route("/time/today", methods=["GET"])
def get_deliveries_today():
    """
    This will get today's deliveries
    """

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.expected_delivery_date == date.today()) 
        .all())

    customer_schema = Delivery_Delivery_schema(many=True)
    return jsonify(customer_schema.dump(deliveries))



@delivery.route("/edit/<int:delivery_id>", methods=["POST"])
def edit_a_delivery(delivery_id):
    """
    This will create a delivery using a customer id
    """
    get_delivery = db.session \
        .query(Delivery_Delivery) \
        .filter(Delivery_Delivery.id == delivery_id) \
        .first()


    get_customer = db.session \
        .query(Customer_Customer) \
        .filter(Customer_Customer.id == get_delivery.customer_id) \
        .first()

    if not get_delivery:
        return jsonify({"ok": False}), 200
    else:
        gallons_ordered = request.json["gallons_ordered"]
        delivery_status = request.json["delivery_status"]
        when_to_deliver = request.json["expected_delivery_date"]

        dispatcher_notes_taken = request.json["dispatcher_notes_taken"]
        customer_wants_fill = request.json["customer_asked_for_fill"]
        card_payment = request.json["credit"]
        cash_payment = request.json["cash"]
        delivery_driver_id = request.json["driver_employee_id"]


        get_driver = (db.session
                       .query(Employee_Employee)
                       .filter(Employee_Employee.id == delivery_driver_id)
                       .first())
        if request.json["credit_card_id"]:
            card_payment_id = request.json["credit_card_id"]
        else:
            card_payment_id = None


        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


        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 customer_wants_fill is True:
            customer_wants_fill = 1
        else:
            customer_wants_fill = 0

        same_day_info = request.json["same_day"]
        if same_day_info is True:
            same_day_info = 1
        else:
            same_day_info = 0

        prime_info = request.json["prime"]
        if prime_info is True:
            prime_info = 1
        else:
            prime_info = 0

        get_delivery.delivery_status = delivery_status
        get_delivery.gallons_ordered = gallons_ordered
        get_delivery.customer_asked_for_fill = customer_wants_fill
        get_delivery.expected_delivery_date = when_to_deliver
        get_delivery.dispatcher_notes = dispatcher_notes_taken
        get_delivery.prime = prime_info
        get_delivery.same_day = same_day_info
        get_delivery.gallons_ordered = gallons_ordered
        get_delivery.payment_type = delivery_payment_method
        get_delivery.payment_card_id = card_id_from_customer
        get_delivery.driver_last_name = get_driver.employee_last_name
        get_delivery.driver_first_name = get_driver.employee_first_name
        get_delivery.driver_employee_id = get_driver.id

        db.session.add(get_delivery)
        db.session.commit()

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


@delivery.route("/create/<int:user_id>", methods=["POST"])
def create_a_delivery(user_id):
    """
    This will create a delivery using a customer id
    """
    get_customer = db.session\
        .query(Customer_Customer)\
        .filter(Customer_Customer.id == user_id)\
        .first()
        
    get_today_price = db.session\
        .query(Pricing_Oil_Oil)\
        .order_by(Pricing_Oil_Oil.id.desc())\
        .first() 


    if not get_customer:
        return jsonify({"ok": False}), 200
    else:
        gallons_ordered = request.json["gallons_ordered"]
        customer_wants_fill = request.json["customer_asked_for_fill"]
        when_to_deliver = request.json["expected_delivery_date"]
        dispatcher_notes_taken = request.json["dispatcher_notes_taken"]
        prime_info = request.json["prime"]
        same_day_info = request.json["same_day"]

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

        delivery_driver_id = request.json["driver_employee_id"]

        get_driver = (db.session
                       .query(Employee_Employee)
                       .filter(Employee_Employee.id == delivery_driver_id)
                       .first())

        driver_l_name = get_driver.employee_last_name
        driver_f_name = get_driver.employee_first_name
        driver_emp_id = get_driver.id

        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 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

                # 0 = cash only 
        # 1 = credit only 
        # 2 = credit /cash 
        # 3 unknown 
        
        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 customer_wants_fill is True:
            customer_fill_up = 1
            gallons_ordered = 250
        else:
            customer_fill_up = 0

        if prime_info is True:
            prime_asked = 1
        else:
            prime_asked = 0

        if same_day_info is True:
            same_day_asked = 1
        else:
            same_day_asked = 0


        customer_filled_name = get_customer.customer_last_name + ' ' + get_customer.customer_first_name
        now = datetime.utcnow()


        
        
        # Pricing
        if customer_fill_up == 1:
            precharge_amount = (250 * get_today_price.price_for_customer)
            print(precharge_amount)
        else:
            precharge_amount = int(gallons_ordered) * get_today_price.price_for_customer

        if same_day_asked == 1 and prime_asked == 0:
            total_precharge_amount = precharge_amount + get_today_price.price_same_day
            print(total_precharge_amount)
            print(precharge_amount)
            print(get_today_price.price_same_day)

        elif prime_asked == 1 and same_day_asked == 0:
            total_precharge_amount = precharge_amount + get_today_price.price_prime

        else:
            total_precharge_amount = precharge_amount + get_today_price.price_prime + get_today_price.price_same_day


        new_delivery = Delivery_Delivery(
            customer_id=get_customer.id,
            customer_address=get_customer.customer_address,
            customer_name=customer_filled_name,
            customer_town=get_customer.customer_town,
            customer_state=get_customer.customer_state,
            customer_zip=get_customer.customer_zip,
            gallons_ordered=gallons_ordered,
            customer_asked_for_fill=customer_fill_up,
            gallons_delivered=0,
            customer_filled=0,
            delivery_status=0,
            when_ordered=now,
            when_delivered=None,
            expected_delivery_date=when_to_deliver,
            automatic=get_customer.customer_automatic,
            oil_id=get_today_price.id,
            supplier_price=get_today_price.price_from_supplier,
            customer_price=get_today_price.price_for_customer,
            customer_temperature=None,
            dispatcher_notes=dispatcher_notes_taken,
            prime=prime_asked,
            same_day=same_day_asked,
            payment_type=delivery_payment_method,
            payment_card_id=card_id_from_customer,
            pre_charge_amount=total_precharge_amount,
            total_price=precharge_amount,
            final_price=0,
            driver_last_name=driver_l_name,
            driver_first_name=driver_f_name,
            driver_employee_id=driver_emp_id,
        )
        
        db.session.add(new_delivery)
        db.session.commit()

        return jsonify({
            "ok": True,
            'delivery_id': new_delivery.id,
        }), 200



@delivery.route("/cancel/<int:delivery_id>", methods=["POST"])
def cancel_a_delivery(delivery_id):
    """
    This will cancel a delivery
    """
    get_delivery = db.session\
        .query(Delivery_Delivery)\
        .filter(Delivery_Delivery.id == delivery_id)\
        .first()
       
    get_delivery.delivery_status = 3
    db.session.add(get_delivery)
    db.session.commit()
    
    return jsonify({"ok": True}), 200


@delivery.route("/delivered/<int:delivery_id>", methods=["POST"])
def mark_as_delivered(delivery_id):
    """
    This will mark the delivery as delivered
    """
    # how many gallons delivered
    gallons_put_into_tank = request.json["gallons_put_into_tank"]
    # was the tank full or not
    was_it_filled = request.json["filled"]
    
    get_delivery = db.session\
        .query(Delivery_Delivery)\
        .filter(Delivery_Delivery.id == delivery_id)\
        .first()
       
    get_delivery.delivery_status = 1
    get_delivery.gallons_delivered = gallons_put_into_tank
    get_delivery.customer_filled = was_it_filled

    db.session.add(get_delivery)
    db.session.commit()
    
    return jsonify({"ok": True}), 200


@delivery.route("/partial/<int:delivery_id>", methods=["POST"])
def partial_delivery(delivery_id):
    """
    This will mark the delivery as delivered
    """
    # how many gallons delivered
    gallons_put_into_tank = request.json["gallons_put_into_tank"]
    
    get_delivery = db.session\
        .query(Delivery_Delivery)\
        .filter(Delivery_Delivery.id == delivery_id)\
        .first()
       
    get_delivery.delivery_status = 4
    get_delivery.gallons_delivered = gallons_put_into_tank
    get_delivery.customer_filled = 0

    db.session.add(get_delivery)
    db.session.commit()
    
    return jsonify({"ok": True}), 200


@delivery.route("/note/technician/<int:delivery_id>", methods=["PUT"])
def delivery_note_driver(delivery_id):
    
    """
    Update a service call diagnosis
    """   
    #
    driver_notes = request.json["driver_notes"]
    now = datetime.utcnow()
    
    user = (db.session
        .query(Auth_User)
        .filter(Auth_User.id == current_user.id)
        .first())
        
    get_delivery = (db.session
        .query(Delivery_Delivery)
        .filter(Delivery_Delivery.id == delivery_id)
        .first())
        
    create_new_note = Delivery_Notes_Driver(
        delivery_id=get_delivery.id,
        driver_comments=driver_notes,
        time_added=now,
        driver_id=user.id,
        driver_name=user.user,
    )
    
    db.session.add(create_new_note)
    db.session.commit()
    
    return jsonify({"ok": True}), 200


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

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


@delivery.route("/updatestatus/outfordelivery", methods=["GET"])
def move_waiting_to_outtodelivery():
    """
    This will get deliveries not done
    """
    counter = 0

    deliveries = (db.session 
        .query(Delivery_Delivery) 
        .filter(Delivery_Delivery.delivery_status == 0) 
        .filter(Delivery_Delivery.expected_delivery_date == date.today()) 
        .all())
    for f in deliveries:
        f.delivery_status = 2
        db.session.add(f)
        counter = counter + 1
    if counter > 0:
        db.session.commit()
        return jsonify({
            "ok": True,
            'update': True,
        }), 200

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


@delivery.route("/total/<int:delivery_id>", methods=["GET"])
def calculate_total(delivery_id):
    """
    This will get deliveries not done
    """


    get_delivery = (db.session
        .query(Delivery_Delivery)
        .filter(Delivery_Delivery.id == delivery_id)
        .first())
    
    get_price_query = (db.session
                    .query(Pricing_Oil_Oil)
                    .order_by(Pricing_Oil_Oil.date.asc())
                    .first())
    
    
    if get_delivery.prime == 1:
        priceprime = get_price_query.price_prime
    else:
        priceprime = 0
        
    if get_delivery.same_day == 1:
        pricesameday = get_price_query.price_same_day
    else:
        pricesameday = 0
    
    total = float(get_delivery.total_price) + float(priceprime) + float(pricesameday)
    
    return jsonify({
        "ok": True,
        'priceprime': priceprime,
        'pricesameday': pricesameday,
        'total_amount':total,
    }), 200