WerkoutIOS/iphone/Werkout_ios/APIModels/Workout.swift

//
//  Workout.swift
//  Werkout_ios
//
//  Created by Trey Tartt on 6/14/23.
//

import Foundation

struct Workout: Codable, Identifiable, Equatable {
    static func == (lhs: Workout, rhs: Workout) -> Bool {
        lhs.id == rhs.id
    }
    
    let id: Int
    let name: String
    let description: String?
    let supersets: [Superset]?
    let registeredUser: RegisteredUser?
    let muscles: [String]?
    let equipment: [String]?
    let exercise_count: Int?
    let createdAt: Date?
    let estimatedTime: Double?
    let allSupersetExecercise: [SupersetExercise]?
    
    enum CodingKeys: String, CodingKey {
        case id, name, description, supersets, exercise_count, muscles, equipment
        case registeredUser = "registered_user"
        case createdAt = "created_at"
        case estimatedTime = "estimated_time"
        case allSupersetExecercise = "all_superset_exercise"
    }

    private static let createdAtFormatter: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssX"
        formatter.locale = Locale(identifier: "en_US_POSIX")
        return formatter
    }()
    
    init(id: Int,
         name: String,
         description: String? = nil,
         supersets: [Superset]? = nil,
         registeredUser: RegisteredUser? = nil,
         muscles: [String]? = nil,
         equipment: [String]? = nil,
         exercise_count: Int? = nil,
         createdAt: Date? = nil,
         estimatedTime: Double? = nil,
         allSupersetExecercise: [SupersetExercise]? = nil) {
        self.id = id
        self.name = name
        self.description = description
        self.supersets = supersets
        self.registeredUser = registeredUser
        self.muscles = muscles
        self.equipment = equipment
        self.exercise_count = exercise_count
        self.createdAt = createdAt
        self.estimatedTime = estimatedTime
        self.allSupersetExecercise = allSupersetExecercise
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)

        self.name = try container.decodeIfPresent(String.self, forKey: .name) ?? "NA"
        self.description = try container.decodeIfPresent(String.self, forKey: .description)
        self.registeredUser = try container.decodeIfPresent(RegisteredUser.self, forKey: .registeredUser)
        self.id = try container.decode(Int.self, forKey: .id)
        self.supersets = try container.decodeIfPresent([Superset].self, forKey: .supersets)
        
        self.equipment = try container.decodeIfPresent([String].self, forKey: .equipment)
        self.muscles = try container.decodeIfPresent([String].self, forKey: .muscles)
        self.exercise_count = try container.decodeIfPresent(Int.self, forKey: .exercise_count)
        
        let createdAtStr = try container.decodeIfPresent(String.self, forKey: .createdAt)
        self.createdAt = createdAtStr.flatMap { Self.createdAtFormatter.date(from: $0) }
        
        self.estimatedTime = try container.decodeIfPresent(Double.self, forKey: .estimatedTime)
        
        allSupersetExecercise = try container.decodeIfPresent([SupersetExercise].self, forKey: .allSupersetExecercise)
    }
}

extension Array where Element == Workout {
    func filterWorkouts(nameSearchString: String,
                        musclesSearchString: Set<String>,
                        equipmentSearchString: Set<String>,
                        filteredRegisterdUser: RegisteredUser?) -> [Workout] {
        var matchingWorkouts = [Workout]()
        
        if matchingWorkouts.isEmpty {
            matchingWorkouts.append(contentsOf: self)
        }
        
        if (!nameSearchString.isEmpty && nameSearchString.count > 0) {
            matchingWorkouts = self.filter({
                if $0.name.lowercased().contains(nameSearchString.lowercased()) {
                    return true
                }
                return false
            })
        }
        
        if (!equipmentSearchString.isEmpty && equipmentSearchString.count > 0) {
            matchingWorkouts = matchingWorkouts.filter({
                if let equipment = $0.equipment?.joined(separator: "").lowercased() {
                    for word in equipmentSearchString {
                        if equipment.contains(word.lowercased()) {
                            return true
                        }
                    }
                    return false
                }
                return false
            })
        }
        
        if (!musclesSearchString.isEmpty && musclesSearchString.count > 0) {
            matchingWorkouts = matchingWorkouts.filter({
                if let muscles = $0.muscles?.joined(separator: "").lowercased() {
                    for word in musclesSearchString {
                        if muscles.contains(word.lowercased()) {
                            return true
                        }
                    }
                    return false
                }
                return false
            })
        }
        
        if let filteredRegisterdUser = filteredRegisterdUser {
            matchingWorkouts = matchingWorkouts.filter({
                $0.registeredUser == filteredRegisterdUser
            })
        }
        
        return matchingWorkouts
    }
}