class AppDelegate: NSObject, UIApplicationDelegate {
    func application(_ application: UIApplication,
                        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        
        FirebaseApp.configure()
        permissionRequest()
        UIApplication.shared.registerForRemoteNotifications()
        
        return true
    }
    
    func permissionRequest() {
        /*
            Access the user notification center and request permission to send notifications
            */
        let center = UNUserNotificationCenter.current()
        center.requestAuthorization(options: [.alert, .sound]) { granted, error in
            if let error = error {
                print(error)
            }
        }
        
        /*
            Define an action allowing the user to dismiss the air quality alert and add this action
            to an AirQualityNotification Category of notifications.
            */
        let dismissAction = UNNotificationAction(identifier: "DISMISS", title: "OK", options: [])
        let airQualityNotification = UNNotificationCategory(identifier: "AIR_QUALITY", actions: [dismissAction], intentIdentifiers: [])
        center.setNotificationCategories([airQualityNotification])
    }
                            

func application(
    _ application: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
) {
    let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
    let token = tokenParts.joined()
    print("Device Token: \(token)")
    
    // send token to web server
    let url = URL(string: Secrets.APNsServer)
    
    var request = URLRequest(url: url!)
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpMethod = "POST"
    let parameters: [String: Any] = ["ID": token]
    
    do {
        request.httpBody = try JSONSerialization.data(withJSONObject: parameters)
    } catch {
        print("Could not serialize device token: \(error.localizedDescription)")
        return
    }
    
    let session = URLSession.shared
    let task = session.dataTask(with: request) { data, response, error in
        if let error = error {
            print("Error initiating data task: \(error.localizedDescription)")
            return
        }
        
        
        guard let httpResponse = response as? HTTPURLResponse,
                (httpResponse.statusCode == 201)
        else {
            print("Invalid response from APNs server")
            return
        }
    }
    task.resume()
}

func application(
    _ application: UIApplication,
    didFailToRegisterForRemoteNotificationsWithError error: Error
) {
    print("Failed to register for remote notifications: \(error)")
}
}
                            

struct ContentView: View {
    @State var apiResponse: Response?  // used to hold information received from API (see Python/alert.py)
    @State var showAlert = false  // controls the display of the alert defined in this file
    
    var body: some View {
        NavigationView{
            List {
                NavigationLink{
                    HourlyList()
                } label: {
                    Text("Hourly")
                }
                NavigationLink{
                    DailyList()
                } label: {
                    Text("Daily")
                }
                NavigationLink{
                    WeeklyList()
                } label: {
                    Text("Weekly")
                }
                NavigationLink{
                    MonthlyList()
                } label: {
                    Text("Monthly")
                }
            }
            .navigationBarTitleDisplayMode(.large)
            .navigationTitle("Measurements")
            .onAppear {
                requestAlert()
            }
            .alert(isPresented: $showAlert) {
                Alert(title: Text("Air Quality has exceeded WHO guidelines"), message: Text("On \(apiResponse!.time) \(apiResponse!.pollutant) concentration was measured at \(apiResponse!.value) mcg/L"), dismissButton: .default(Text("OK")))
            }
        }
    }
    
    func requestAlert() { // this function is unrelated to the alerts so far discussed here, 
                          // and will be discussed in the section 'Analyzing measurements in Cloud Storage'
        let api = URL(string: Secrets.AlertAPI)
        let sesson = URLSession(configuration: .default)
        let task = sesson.dataTask(with: api!) { data, response, error in
            if error == nil {
                let decoder = JSONDecoder()
                if let safeData = data {
                    do {
                        let results = try decoder.decode(Response.self, from: safeData)
                        self.apiResponse = results
                        print(results)
                        if apiResponse!.alert == true {
                            showAlert = true
                        }
                    } catch {
                        print(error)
                    }
                }
            }
        }
        task.resume()
    }
    
}
                            

public class CloudStorage: ObservableObject {

    let storage = Storage.storage() // a reference to the Cloud Storage bucket used in this project
    
    /*
        Create arrays of StorageReference types for each measurement interval
        */
    @Published public var hourlyItems = [StorageReference]()
    @Published public var dailyItems = [StorageReference]()
    @Published public var weeklyItems = [StorageReference]()
    @Published public var monthlyItems = [StorageReference]()
    
    func format_date(_ string: String) -> Date {
        let dateAsString = string
        let df = DateFormatter()
        df.dateFormat = "EEE MMM d HH:mm:ss y"
        df.timeZone = TimeZone(identifier: "MST")
        df.locale = Locale(identifier: "en_US_POSIX")
        return df.date(from: dateAsString)!
    }
    
    init() {
        Task(priority: .high) {
            let ref = storage.reference()
            ref.listAll { (result, error) in
                if let error = error {
                    print(error)
                }
                if let result = result {
                    /* measurement files are prefixed by the intervals in which they were
                        taken: hourly, daily, weekly, and monthly.
                        */
                    for prefix in result.prefixes {
                        prefix.listAll { result, error in
                            if let error = error {
                                print(error)
                            }
                            switch prefix.name {
                                
                            case "hourly":
                                if let result = result {
                                    for item in result.items {
                                        /*
                                            Format how hourly measureent files are displayed to the user as a
                                            more readable date format: Nov 6. 2022 at 12:00 AM
                                            */
                                        let fileName = item.name // Sun Nov 6 07:49:04 2022
                                        let beginSubString = fileName.startIndex
                                        let endSubString = fileName.index(fileName.endIndex, offsetBy: -4)
                                        let range = beginSubString..24 measurement files.
                                            */
                                        let measurementDate = self.format_date(stringDescribingDate)
                                        let currentDate = NSDate()
                                        
                                        let currentDay = Calendar.current.dateComponents([.day, .month, .year], from: currentDate as Date)
                                        let measurementDay = Calendar.current.dateComponents([.day, .month, .year], from: measurementDate)
                                        
                                        if (measurementDay == currentDay) { // only show hourly measurements for the current day
                                            self.hourlyItems.append(item)
                                        }
                                        else { // delete the measurements from prior days
                                            item.delete { error in
                                                if let error = error{
                                                    print("Could not delete expired hourly measurement: \(error)")
                                                }
                                            }
                                        }
                                    }
                                }
                                
                            case "daily":
                                if let result = result {
                                    for item in result.items {
                                        self.dailyItems.append(item)
                                    }
                                }
                                
                            case "weekly":
                                if let result = result {
                                    for item in result.items {
                                        self.weeklyItems.append(item)
                                    }
                                }
                                
                            case "monthly":
                                if let result = result {
                                    for item in result.items {
                                        self.monthlyItems.append(item)
                                    }
                                }
                                
                            default:
                                print("Prefix of tyoe \(prefix.name) was not added!!!")
                            }
                            
                        }
                    }
                }
            }
        }
    }
}
                                
                            

struct HourlyList: View {
    @StateObject private var cloudStorage = CloudStorage()
    @State public var chosenFile: String?
    @State var apiResponse: Response?
    @State var showAlert = false
    
    var body: some View {
            List(cloudStorage.hourlyItems, id: \.self) { reference in
                NavigationLink{
                    DataView(chosenFile: reference.fullPath)
                } label: {
                    /*
                        It is necessary to perform some work already performed in CloudStorage.swift
                        in order to display hourly measurement files in a more readable format (see CloudStorage.swift).
                        
                        This is because an hourlyItem is really an array of type StorageReference, defined
                        in the Firebase Storage package, and is not capable of holding an additional member
                        describing the more readable filename.
                        
                        Why is this work still performed in CloudStorage.swift?
                        Because it simplifies the process of determining a measurement (StorageReference)
                        date, and this is necessary to remove old measurements from Cloud Storage.
                        */
                    let fileName = reference.fullPath
                    let beginSubString = fileName.index(fileName.startIndex, offsetBy: 7)
                    let endSubString = fileName.index(fileName.endIndex, offsetBy: -4)
                    let range = beginSubString..<endSubString
                    let subString = fileName[range]
                    let stringDescribingDate = String(subString)
                    
                    Text(self.format_date(stringDescribingDate))
                }
            }
        .navigationBarTitleDisplayMode(.large)
        .navigationTitle("Hourly")
        .onAppear {
            requestAlert()
        }
        .alert(isPresented: $showAlert) {
            Alert(title: Text("Air Quality has exceeded WHO guidelines"), message: Text("On \(apiResponse!.time) \(apiResponse!.pollutant) concentration was measured at \(apiResponse!.value) mcg/L"), dismissButton: .default(Text("OK")))
        }
    }
    
    /*
        Provided a string, this function will format that string according to a provided
        timezone and locale. 
        */
    func format_date(_ string: String) -> String {
        let dateAsString = string
        let df = DateFormatter()
        df.dateFormat = "EEE MMM d HH:mm:ss y"
        df.timeZone = TimeZone(identifier: "MST")
        df.locale = Locale(identifier: "en_US_POSIX")
        let date = df.date(from: dateAsString)!
        return DateFormatter.localizedString(from: date, dateStyle: .medium, timeStyle: .short)
    }
    
    func requestAlert() {
        let api = URL(string: "http://ec2-35-160-195-137.us-west-2.compute.amazonaws.com:8080/")
        let sesson = URLSession(configuration: .default)
        let task = sesson.dataTask(with: api!) { data, response, error in
            if error == nil {
                let decoder = JSONDecoder()
                if let safeData = data {
                    do {
                        let results = try decoder.decode(Response.self, from: safeData)
                        self.apiResponse = results
                        print(results)
                        if apiResponse!.alert == true {
                            showAlert = true
                        }
                    } catch {
                        print(error)
                    }
                }
            }
        }
        task.resume()
    }
}
                            

struct DataView: View {
    let storage = Storage.storage()
    @State public var measurements = [Measurement]() // holds all measurements present in the chosen file
    let chosenFile: String // reference to the file that the user tapped
    
    // API Response and alert handling
    @State var apiResponse: Response?
    @State var showAlert = false
    
    
    func downloadFile(filePath: String) {
        measurements = [Measurement]()
        let ref = storage.reference(forURL: "\(Secrets.StorageBucket)\(chosenFile)")
        var localURL: URL?
        
        do { // create local download url
            let documentURL = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
            localURL = documentURL.appendingPathComponent(chosenFile)
        } catch {
            print("Error generating local download URL")
            return
        }
        
        if let safeURL = localURL { // download chosen file
            _ = ref.write(toFile: safeURL) { url, error in
                if let error = error {
                    print(error)
                    return
                } else {
                    let raw_measurements = parseCSV(safeURL)
                    for each in raw_measurements {
                        let measurement: [String] = each.components(separatedBy: ",")
                        
                        // final row contains nothing, skip this row
                        guard (measurement.count == 3) else {
                            return
                        }
                        
                        measurements.append(Measurement(id: format_date(measurement[2]), type: measurement[0], measurement: Float(measurement[1]) ?? 0.0))
                    }
                }
            }
        }
    }
    
    func format_date(_ string: String) -> Date {
        let dateAsString = string
        let df = DateFormatter()
        df.dateFormat = "EEE MMM d HH:mm:ss y "
        df.timeZone = TimeZone(identifier: "MST")
        df.locale = Locale(identifier: "en_US_POSIX")
        return df.date(from: dateAsString)!
    }
    
    func parseCSV(_ url: URL) -> Array {
        do {
            let content = try String(contentsOf: url)
            let parsedCSV: [String] = content.components(separatedBy: "\n")
            return parsedCSV
        }
        catch {
            print("Error parsing CSV")
            return []
        }
    }
    
    func requestAlert() {
        let api = URL(string: Secrets.AlertAPI)
        let sesson = URLSession(configuration: .default)
        let task = sesson.dataTask(with: api!) { data, response, error in
            if error == nil {
                let decoder = JSONDecoder()
                if let safeData = data {
                    do {
                        let results = try decoder.decode(Response.self, from: safeData)
                        self.apiResponse = results
                        print(results)
                        if apiResponse!.alert == true {
                            showAlert = true
                        }
                    } catch {
                        print(error)
                    }
                }
            }
        }
        task.resume()
    }
    
    var body: some View {
        VStack {
            Text(chosenFile)
            Spacer()
            Chart(measurements){
                LineMark (
                    x: .value("Time", $0.id),
                    y: .value("Measurement", $0.measurement)
                )
                .foregroundStyle(by: .value("Measurement Type", $0.type))
            }
            .chartLegend(position: .top, alignment: .center)
        }
        .onAppear {
            downloadFile(filePath: chosenFile)
            requestAlert()
        }
        .alert(isPresented: $showAlert) {
            Alert(title: Text("Air Quality has exceeded WHO guidelines"), message: Text("On \(apiResponse!.time) \(apiResponse!.pollutant) concentration was measured at \(apiResponse!.value) mcg/L"), dismissButton: .default(Text("OK")))
        }
        .padding()
    }
}