ViewExtensionBenBranch

//
//  File.swift
//  projet-session-ios
//
//  Created by Benoit Vézina on 2019-03-31.
//  Copyright © 2019 com.dmi.uqtr. All rights reserved.
//

import Foundation
import UIKit
import CoreData

extension UIViewController {

    /******************* FETCH ********************/

    func fetchAllUsers() -> [UtilisateurMO]? {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let fetch = NSFetchRequest<UtilisateurMO>(entityName: "Utilisateur")
        var users = [UtilisateurMO]()
        do {
            let results = try moc.fetch(fetch)
            if results.count < 1 {
                // TODO erreur fetch core data
            }
            users = results
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }
        return users
    }

    func fetchUser(email: String) -> UtilisateurMO? {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let fetch = NSFetchRequest<UtilisateurMO>(entityName: "Utilisateur")
        fetch.predicate = NSPredicate(format: "courriel == %@", email)
        let user:UtilisateurMO
        do {
            let results = try moc.fetch(fetch)
            if results.count < 1 {
                return nil
            }
            user = results[0]
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }
        return user
    }

    func fetchCurrentUser() -> UtilisateurMO?
    {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let emailObject = UserDefaults.standard.object(forKey: "email") as? String
        if emailObject == nil {
            return nil
        }
        let email:String = emailObject!

        let fetch = NSFetchRequest<UtilisateurMO>(entityName: "Utilisateur")
        fetch.predicate = NSPredicate(format: "courriel == %@", email)
        let user:UtilisateurMO
        do {
            let results = try moc.fetch(fetch)
            if results.count < 1 {
                // TODO erreur fetch core data
            }
            user = results[0]
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }
        return user
    }

    func fetchAllLogements() -> [LogementMO]? {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let fetch = NSFetchRequest<LogementMO>(entityName: "Logement")
        var logements = [LogementMO]()
        do {
            let results = try moc.fetch(fetch)
            logements = results
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }
        return logements
    }

    func fetchConversationById(id: NSManagedObjectID) -> ConversationMO {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let conversation = moc.object(with: id) as! ConversationMO

        return conversation
    }

    func fetchAllMessages() -> [MessageMO]? {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let fetch = NSFetchRequest<MessageMO>(entityName: "Message")
        var messages = [MessageMO]()
        do {
            let results = try moc.fetch(fetch)
            messages = results
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }
        return messages
    }

    func fetchMessagesByConversationId(id: NSManagedObjectID) -> [MessageMO]? {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let conversation = moc.object(with: id) as! ConversationMO
        let messagesObject = conversation.messages
        if messagesObject == nil {
            return nil
        }
        let messagesArray = Array(messagesObject!)
        let messages = messagesArray as! [MessageMO]

        return messages
    }

    func fetchMessagesByUsersPrenom(prenom1: String, prenom2: String) -> [MessageMO]? {
        var messagesToReturn = [MessageMO]()
        let messagesObject = fetchAllMessages()
        if messagesObject == nil {
            return nil
        }
        let messages = messagesObject!
        for aMessage in messages {
            let isTo = aMessage.to == prenom1 || aMessage.to == prenom2
            let isFrom = aMessage.from == prenom1 || aMessage.from == prenom2
            if isTo && isFrom {
                messagesToReturn.append(aMessage)
            }
        }

        return messagesToReturn
    }

    /******************* INSERT ********************/

    func insertUser(fname: String, lname: String, tel: String, email: String, password: String) {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let user = NSEntityDescription.insertNewObject(forEntityName:
            "Utilisateur", into: moc) as! UtilisateurMO
        user.setValue(fname, forKey: "prenom")
        user.setValue(lname, forKey: "nom")
        user.setValue(password, forKey: "password")
        user.setValue(email, forKey: "courriel")
        user.setValue(tel, forKey: "telephone")
        do {
            try moc.save()
        } catch {
            let nserror = error as NSError
            fatalError("error \(nserror), \(nserror.userInfo)")
        }
    }

    func insertMessage(to: String, from: String, contenu: String, date: String, conversationId: NSManagedObjectID) -> MessageMO {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let message = NSEntityDescription.insertNewObject(forEntityName: "Message", into: moc) as! MessageMO
        message.setValue(to, forKey: "to")
        message.setValue(from, forKey: "from")
        message.setValue(contenu, forKey: "contenu")
        if date == "" {
            message.setValue(getDate(), forKey: "date")
        } else {
            message.setValue(date, forKey: "date")
        }

        let conversation = moc.object(with: conversationId) as! ConversationMO
        conversation.messages!.adding(message)



        do {
            try moc.save()
        } catch {
            let nserror = error as NSError
            fatalError("error \(nserror), \(nserror.userInfo)")
        }

        return message
    }

    /******************* DELETE ********************/

    func deleteAll() {
        deleteAllUsers()
        deleteAllLogement()
        deleteAllConversation()
        deleteAllMessage()
    }

    func deleteAllUsers() {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let fetch = NSFetchRequest<UtilisateurMO>(entityName: "Utilisateur")
        var users = [UtilisateurMO]()
        do {
            let results = try moc.fetch(fetch)
            if results.count < 1 {
                // TODO erreur fetch core data
            }
            users = results
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }

        for user in users {
            moc.delete(user)
        }
        do {
            try moc.save()
        } catch {
            let nserror = error as NSError
            fatalError("error \(nserror), \(nserror.userInfo)")
        }
    }

    func deleteAllLogement() {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let fetch = NSFetchRequest<LogementMO>(entityName: "Logement")
        var logements = [LogementMO]()
        do {
            let results = try moc.fetch(fetch)
            if results.count < 1 {
                // TODO erreur fetch core data
            }
            logements = results
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }

        for logement in logements {
            moc.delete(logement)
        }
        do {
            try moc.save()
        } catch {
            let nserror = error as NSError
            fatalError("error \(nserror), \(nserror.userInfo)")
        }
    }

    func deleteAllConversation() {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let fetch = NSFetchRequest<ConversationMO>(entityName: "Conversation")
        var conversations = [ConversationMO]()
        do {
            let results = try moc.fetch(fetch)
            if results.count < 1 {
                // TODO erreur fetch core data
            }
            conversations = results
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }

        for conversation in conversations {
            moc.delete(conversation)
        }
        do {
            try moc.save()
        } catch {
            let nserror = error as NSError
            fatalError("error \(nserror), \(nserror.userInfo)")
        }
    }

    func deleteAllMessage() {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        let fetch = NSFetchRequest<MessageMO>(entityName: "Message")
        var messages = [MessageMO]()
        do {
            let results = try moc.fetch(fetch)
            if results.count < 1 {
                // TODO erreur fetch core data
            }
            messages = results
        } catch {
            fatalError("Failed to fetch verif: \(error)")
        }

        for message in messages {
            moc.delete(message)
        }
        do {
            try moc.save()
        } catch {
            let nserror = error as NSError
            fatalError("error \(nserror), \(nserror.userInfo)")
        }
    }

    /******************* ORDER ********************/

    func orderConversationArrayByDate(conversations: [ConversationMO]) -> [ConversationMO] {
        var orderedArray = [ConversationMO]()
        var tempArray = conversations
        var mostRecent = tempArray[0]
        var mostRecentIndex = 0

        while orderedArray.count < conversations.count {
            for (key, conversation) in tempArray.enumerated() {
                if conversation.date_dernier_message! < mostRecent.date_dernier_message! {
                    mostRecent = conversation
                    mostRecentIndex = key
                }
            }
            orderedArray.append(mostRecent)
            tempArray.remove(at: mostRecentIndex)
            if tempArray.count > 0 {
                mostRecent = tempArray[0]
                mostRecentIndex = 0
            }
        }

        return orderedArray
    }

    /******************* MISC ********************/

    func insertDefaultEntities()
    {
        let core = getPersistentContainerAndMoc()
        let moc = core.1

        var messages1 = [MessageMO]()

        let message1 = NSEntityDescription.insertNewObject(forEntityName: "Message", into: moc) as! MessageMO
        message1.setValue("nathan", forKey: "to")
        message1.setValue("ben", forKey: "from")
        message1.setValue("Bienvenue sur LogEtudiant!", forKey: "contenu")
        message1.setValue(getDate(), forKey: "date")
        messages1.append(message1)

        let message2 = NSEntityDescription.insertNewObject(forEntityName: "Message", into: moc) as! MessageMO
        message2.setValue("ben", forKey: "to")
        message2.setValue("nathan", forKey: "from")
        message2.setValue("Merci!", forKey: "contenu")
        message2.setValue(getDate(), forKey: "date")
        messages1.append(message2)

        var messages2 = [MessageMO]()

        let message3 = NSEntityDescription.insertNewObject(forEntityName: "Message", into: moc) as! MessageMO
        message3.setValue("ben", forKey: "to")
        message3.setValue("alex", forKey: "from")
        message3.setValue("Hey ben!", forKey: "contenu")
        message3.setValue(getDate(), forKey: "date")
        messages2.append(message3)

        let message4 = NSEntityDescription.insertNewObject(forEntityName: "Message", into: moc) as! MessageMO
        message4.setValue("alex", forKey: "to")
        message4.setValue("ben", forKey: "from")
        message4.setValue("Yo alex!", forKey: "contenu")
        message4.setValue(getDate(), forKey: "date")
        messages2.append(message4)

        var conversationsBen = [ConversationMO]()
        var conversationsNat = [ConversationMO]()
        var conversationsAlex = [ConversationMO]()

        let conversation1 = NSEntityDescription.insertNewObject(forEntityName: "Conversation", into: moc) as! ConversationMO
        let messagesSet1 = NSSet(array: messages1)
        conversation1.setValue(messagesSet1, forKey: "messages")
        conversation1.setValue(getDate(), forKey: "date_dernier_message")
        conversationsBen.append(conversation1)
        conversationsNat.append(conversation1)

        let conversation2 = NSEntityDescription.insertNewObject(forEntityName: "Conversation", into: moc) as! ConversationMO
        let messagesSet2 = NSSet(array: messages2)
        conversation2.setValue(messagesSet2, forKey: "messages")
        conversation2.setValue("2018-04-14 23:59", forKey: "date_dernier_message")
        conversationsBen.append(conversation2)
        conversationsAlex.append(conversation2)

        let ben = NSEntityDescription.insertNewObject(forEntityName:
            "Utilisateur", into: moc) as! UtilisateurMO
        ben.setValue("ben", forKey: "prenom")
        ben.setValue("vez", forKey: "nom")
        ben.setValue("123", forKey: "password")
        ben.setValue("bmail", forKey: "courriel")
        ben.setValue("123456789", forKey: "telephone")
        var conversationsSet = NSSet(array: conversationsBen)
        ben.setValue(conversationsSet, forKey: "conversations")

        let nathan = NSEntityDescription.insertNewObject(forEntityName:
            "Utilisateur", into: moc) as! UtilisateurMO
        nathan.setValue("nathan", forKey: "prenom")
        nathan.setValue("sic", forKey: "nom")
        nathan.setValue("123", forKey: "password")
        nathan.setValue("nmail", forKey: "courriel")
        nathan.setValue("24781864", forKey: "telephone")
        conversationsSet = NSSet(array: conversationsNat)
        nathan.setValue(conversationsSet, forKey: "conversations")

        let alex = NSEntityDescription.insertNewObject(forEntityName:
            "Utilisateur", into: moc) as! UtilisateurMO
        alex.setValue("alex", forKey: "prenom")
        alex.setValue("duh", forKey: "nom")
        alex.setValue("123", forKey: "password")
        alex.setValue("amail", forKey: "courriel")
        alex.setValue("846849548", forKey: "telephone")
        conversationsSet = NSSet(array: conversationsAlex)
        alex.setValue(conversationsSet, forKey: "conversations")

        do {
            try moc.save()
            print("Comptes préféfinis: \nemail: bmail, mdp: 123\nemail: nmail, mdp: 123\nemail: amail, mdp: 123")
        } catch {
            let nserror = error as NSError
            fatalError("error \(nserror), \(nserror.userInfo)")
        }
    }

    /******************* PRIVATE ********************/

    private func getDate() -> String
    {
        let date = Date()
        let calendar = Calendar.current
        let year = calendar.component(.year, from: date)
        let month = calendar.component(.month, from: date)
        let monthDoubleDigit = month < 10 ? "0" : ""
        let day = calendar.component(.day, from: date)
        let dayDoubleDigit = day < 10 ? "0" : ""
        let hour = calendar.component(.hour, from: date)
        let hourDoubleDigit = hour < 10 ? "0" : ""
        let minutes = calendar.component(.minute, from: date)
        let minuteDoubleDigit = minutes < 10 ? "0" : ""
        let dateString = "\(year)-\(monthDoubleDigit)\(month)-\(dayDoubleDigit)\(day) \(hourDoubleDigit)\(hour):\(minuteDoubleDigit)\(minutes)"
        return dateString
    }

    private func getPersistentContainerAndMoc() -> (NSPersistentContainer, NSManagedObjectContext) {
        let persistentContainer: NSPersistentContainer = {
            let container = NSPersistentContainer(name: "Logement")
            container.loadPersistentStores(completionHandler:
                { (storeDescription, error) in
                    if let error = error as NSError? {
                        fatalError("error \(error.userInfo)")
                    }
            })
            return container
        }()
        let moc = persistentContainer.viewContext
        return (persistentContainer, moc)
    }

}