//
//  DataService.swift
//  restauracy
//
//  Created by Artur on 04/11/2017.
//  Copyright © 2017 restauracy. All rights reserved.
//

import Foundation
import FirebaseDatabase

class DataService {
    static let shared = DataService()
    var ref: DatabaseReference!
    var ordersRef: DatabaseReference!
    var archivedOrdersRef: DatabaseReference!
    var connectionStatus: Bool = false

    private init() {
        ref = Database.database().reference()
        archivedOrdersRef = ref.child("archivedOrders")
        self.subscribeToOnlineOfflineListener()
        ordersRef = ref.child("activeOrders")

    }

    func loadRestaurant(tableId: String, completion: @escaping (_ data: Dictionary<String, Any>) -> Void) {

        //determine the id of the restaurant based on the table
        ref.child("Tables").queryOrderedByKey().queryEqual(toValue: tableId.makeFirebaseString()).observeSingleEvent(of: .value, with: { (snapshot) in
            guard let value = snapshot.value as? Dictionary<String, Any>,
                let table = value[tableId.makeFirebaseString()] as? Dictionary<String, Any>,
                let restaurantId = table["restaurantId"],
                let tableName = table["name"] as? String
                else {
                    completion([:])
                    return
            }
            //now query the restaurant identified based on the table ID
            self.ref.child("Restaurants").queryOrderedByKey().queryEqual(toValue: restaurantId).observeSingleEvent(of: .value, with: { (snapshot) in
                if let value = snapshot.value as? Dictionary<String, Any> {
                    var result: Dictionary<String, Any> = [:]
                    for (_, tmpValue) in value {
                        result = tmpValue as! Dictionary<String, Any>
                    }
                    Table.shared.name = tableName
                    completion(result)
                    return
                } else {
                    completion([:])
                    return
                }
            }) { (error) in
                completion([:])
                return
            }
        })  { (error) in
            completion([:])
            return
        }
    }

    //////////////MARK: USER MANAGEMENT FUNCTIONS
    func registerUserAtTable(user: User, tableId: String) {
        ref.child("Users").child(user.id).child("currentTable").setValue(tableId)
    }

    //Trigger back-end for user re-authentication as in logging in and changing from anonymous to authenticated user.
    func triggerUserLogin (oldId: String, newId: String) {
        let userRef = ref.child("Users").child(newId).child("triggerLoginFrom")
        userRef.setValue(oldId)
    }

    //Trigger back-end for user log-out (log-in as anonymous)
    func triggerUserLogout (oldId: String, newId: String) {
        let userRef = ref.child("Users").child(newId).child("triggerLogoutFrom")
        userRef.setValue(oldId)
    }

    ///////MARK: order handling functions
    func subscribeToTableChanges(tableId: String) {

        let ordersQuery = ordersRef.queryOrdered(byChild: "tableId").queryEqual(toValue: tableId)

        ordersQuery.observe(.childAdded, with: { (snapshot) -> Void in
            if snapshot.hasChildren() {
                Table.shared.handleOrderAdded(snapshot: snapshot)
            }
        })

        ordersQuery.observe(.childChanged, with: { (snapshot) -> Void in
            if snapshot.hasChildren() {
                Table.shared.handleOrderChanged(snapshot: snapshot)
            }
        })

        ordersQuery.observe(.childRemoved, with: { (snapshot) -> Void in
            if snapshot.hasChildren() {
                Table.shared.handleOrderRemoved(snapshot: snapshot)
            }
        })
    }

    func readUsersPaidOrders(user: User, completion: @escaping (_ result: DataSnapshot) -> Void) {
        let activeOrdersQuery = ref.child("activeOrders").queryOrdered(byChild: "paidByUid")
        activeOrdersQuery.queryEqual(toValue: user.id).observeSingleEvent(of: .value, with: { (snapshot) in
            completion(snapshot)
        })
    }

    func addOrder(order: Order) {
        let orderRef = ordersRef.childByAutoId()
        let storedOrder = order
        storedOrder.id = orderRef.key

        for category in storedOrder.categories {
            category.orderId = storedOrder.id
        }
        orderRef.setValue(storedOrder.toDictionary())
        orderRef.child("timeInitiated").setValue(ServerValue.timestamp())
    }

    func addCategory(category: Category) {
        let categoryRef = ordersRef.child(category.orderId!).child("categories").child(category.id)
        let storedCategory = category
        storedCategory.id = categoryRef.key
        categoryRef.setValue(storedCategory.toDictionary())
    }

    func addMenuItem(menuItem: MenuItem) {
        let itemRef = ordersRef.child((Table.shared.getItemForId(id: menuItem.categoryId) as! Category).orderId!).child("categories").child(menuItem.categoryId).child("menuItems").child(menuItem.id)
        let storedMenuItem = menuItem
        storedMenuItem.id = itemRef.key
        itemRef.setValue(storedMenuItem.toDictionary())
    }

    func addVariant(variant: Variant) {
        let variantRef = ordersRef.child((Table.shared.getItemForId(id: variant.categoryId) as! Category).orderId!).child("categories").child(variant.categoryId).child("menuItems").child(variant.itemId).child("variants").child(variant.id)
        let storedVariant = variant
        storedVariant.id = variantRef.key
        variantRef.setValue(storedVariant.toDictionary())
    }

    func increaseQuantity(menuItem: MenuItem) {
        let itemRef = ordersRef.child((Table.shared.getItemForId(id: menuItem.categoryId) as! Category).orderId!).child("categories").child(menuItem.categoryId).child("menuItems").child(menuItem.id).child("quantity")
        itemRef.setValue(menuItem.quantity + 1)
    }

    func increaseQuantity(variant: Variant) {
        let variantRef = ordersRef.child((Table.shared.getItemForId(id: variant.categoryId) as! Category).orderId!).child("categories").child(variant.categoryId).child("menuItems").child(variant.itemId).child("variants").child(variant.id).child("quantity")
        variantRef.setValue(variant.quantity + 1)
    }

    func updateComment(menuItem: MenuItem, comment: String?) {
        let itemRef = ordersRef.child((Table.shared.getItemForId(id: menuItem.categoryId) as! Category).orderId!).child("categories").child(menuItem.categoryId).child("menuItems").child(menuItem.id).child("comment")
        itemRef.setValue(comment)
    }

    func updateComment(variant: Variant, comment: String?) {
        let variantRef = ordersRef.child((Table.shared.getItemForId(id: variant.categoryId) as! Category).orderId!).child("categories").child(variant.categoryId).child("menuItems").child(variant.itemId).child("variants").child(variant.id).child("comment")
        variantRef.setValue(comment)
    }

    func updatePaidByUid(order: Order, uid: String?) {
        let orderRef = ordersRef.child(order.id).child("paidByUid")
        orderRef.setValue(uid)
    }

    func deleteOrder(order: Order) {
        let orderRef = ordersRef.child(order.id)
        orderRef.removeValue()
    }

    func deleteCategory(category: Category) {
        let categoryRef = ordersRef.child(category.orderId!).child("categories").child(category.id)
        categoryRef.removeValue()
    }

    func deleteMenuItem(menuItem: MenuItem) {
        let itemRef = ordersRef.child((Table.shared.getItemForId(id: menuItem.categoryId) as! Category).orderId!).child("categories").child(menuItem.categoryId).child("menuItems").child(menuItem.id)
        itemRef.removeValue()
    }

    func deleteVariant(variant: Variant) {
        let variantRef = ordersRef.child((Table.shared.getItemForId(id: variant.categoryId) as! Category).orderId!).child("categories").child(variant.categoryId).child("menuItems").child(variant.itemId).child("variants").child(variant.id)
        variantRef.removeValue()
    }

    func assignSessionIdToOrders(orders: [Order], sessionId: String, completion: @escaping (_ result: String) -> Void) {
        var updates: [AnyHashable : Any] = [:]
        for order in orders {
            updates[order.id+"/sessionId"] = sessionId
        }
        ordersRef.updateChildValues(updates, withCompletionBlock: { (err, ref) in
            if err == nil {
                completion("")
            } else {
                completion(err!.localizedDescription)
            }
        })
    }

    func unassignSessionIdToOrders(orders: [Order], sessionId: String, completion: @escaping (_ result: String) -> Void) {
        var updates: [AnyHashable : Any] = [:]
        for order in orders {
            updates[order.id+"/sessionId"] = NSNull()
        }
        ordersRef.updateChildValues(updates, withCompletionBlock: { (err, ref) in
            if err == nil {
                completion("")
            } else {
                completion(err!.localizedDescription)
            }
        })
    }

    func handleOrdersPaid(orders: [Order]) {
        var updates: [AnyHashable : Any] = [:]

        for order in orders {
            var orderDictionary = order.toDictionary()
            orderDictionary["timePaid"] = ServerValue.timestamp()
            updates[order.id] = orderDictionary
        }

        archivedOrdersRef.updateChildValues(updates) { (err, ref) in
            if err == nil {
                var deletions: [AnyHashable : Any] = [:]
                for order in orders {
                    deletions[order.id] = NSNull()
                }

                self.ordersRef.updateChildValues(deletions, withCompletionBlock: { (err, ref) in
                    print(err == nil ? "Update successful" : "Error deleting old orders")
                })

            } else { print("error moving orders from paid!") }
        }
    }

    func removeOrderObservers(){
        if archivedOrdersRef != nil {
            archivedOrdersRef.removeAllObservers()
        }
        if ordersRef != nil {
            ordersRef.removeAllObservers()
        }

        OrderManager.removeOrders()

    }

    func subscribeToArchivedOrderChanges(user: User) {
        archivedOrdersRef.removeAllObservers()

        let archivedOrdersQuery = archivedOrdersRef.queryOrdered(byChild: "ownedByUid").queryEqual(toValue: user.id).queryLimited(toLast: 25)
                archivedOrdersQuery.observe(.childAdded, with: { (snapshot) -> Void in
                    if snapshot.hasChildren() {
                        User.shared.handleArchivedOrderAdded(snapshot: snapshot)
                    }
                })

                archivedOrdersQuery.observe(.childChanged, with: { (snapshot) -> Void in
                    if snapshot.hasChildren() {
                        User.shared.handleArchivedOrderChanged(snapshot: snapshot)
                    }
                })

                archivedOrdersQuery.observe(.childRemoved, with: { (snapshot) -> Void in
                    if snapshot.hasChildren() {
                        User.shared.handleArchivedOrderRemoved(snapshot: snapshot)
                    }
                })
    }

    // MARK: connectivity functions
    func subscribeToOnlineOfflineListener () -> Void {
        let connectedRef = Database.database().reference(withPath: ".info/connected")
        connectedRef.removeAllObservers()

        connectedRef.observe(.value, with: { snapshot in
            if let connected = snapshot.value as? Bool, connected {
                self.connectionStatus = true
            } else {
                self.connectionStatus = false
            }
        })
    }

    func getFirebaseConnectionStatus () -> Bool {
        return self.connectionStatus
    }

//    func loadArchivedOrders (user: User, completion: @escaping (_ orders: [Order]) -> Void) {
//        var tempOrders: [Order] = []
//
//        archivedOrdersRef.queryOrdered(byChild: "ownedByUid").queryEqual(toValue: user.id).observeSingleEvent(of: .value, with: { (snapshot) in
//            for userOrder in snapshot.children {
//                let tempOrder = Order(snapshot: userOrder as! DataSnapshot)
//                tempOrders.append(tempOrder)
//            }
//            tempOrders.sort(by: {$0.id > $1.id})
//            completion(tempOrders)
//        })
//    }
}