block-employee-directory/EmployeeDirectory/Services/MockEmployeeService.swift

//
//  MockEmployeeService.swift
//  EmployeeDirectory
//
//  Created by Matt Bruce on 1/21/25.
//
import Foundation

public class MockEmployeeService: EmployeeServiceProtocol {
    // MARK: - Properties
    public static let shared = MockEmployeeService() // Default shared instance
    private var wrapper: Employees
    private var sortField: EmployeeSortField = .fullName
    private var sortOrder: EmployeeSortOrder = .ascending
    
    // MARK: - Initializer

    public init() {
        let jsonFileName = "localTest"
        guard let url = Bundle.main.url(forResource: jsonFileName, withExtension: "json"),
                let data = try? Data(contentsOf: url),
              let localData = try? JSONDecoder().decode(Employees.self, from: data) else {
            wrapper = .init(employees: [], total: 0, page: 0, perPage: 0)
            return
        }
        wrapper = localData
        sortEmployees()
    }
    
    public func getEmployees() async throws -> Employees {
        return wrapper
    }
    
    public func getEmployees(page: Int, perPage: Int,
                             sortField: EmployeeSortField = .fullName,
                             sortOrder: EmployeeSortOrder = .ascending) async throws -> Employees {
                
        //resort mock data
        if sortField != self.sortField || sortOrder != self.sortOrder {
            self.sortField = sortField
            self.sortOrder = sortOrder
            sortEmployees()
        }
        
        let totalUsers = wrapper.employees.count
        let startIndex = (page - 1) * perPage
        let endIndex = min(startIndex + perPage, totalUsers)

        guard startIndex < totalUsers else {
            return .init(employees: [], total: totalUsers, page: page, perPage: perPage) // Return empty if out of bounds
        }
        
        //paged
        let pagedEmployees = Array(wrapper.employees[startIndex..<endIndex])
        return .init(employees: pagedEmployees, total: totalUsers, page: page, perPage: perPage)
    }
    
    private func sortEmployees() {
        wrapper = .init(employees:  wrapper.employees.sorted(by: sortField, with: sortOrder),
                          total: wrapper.employees.count,
                          page: 1,
                          perPage: 10)
    }
}

extension Array where Element == Employee {
    func sorted(by field: EmployeeSortField, with option: EmployeeSortOrder) -> [Employee] {
        switch field {
        case .fullName:
            return option == .ascending
            ? sorted { $0.fullName < $1.fullName }
            : sorted { $0.fullName > $1.fullName }
            
        case .team:
            return option == .ascending
            ? sorted { $0.team < $1.team || ($0.team == $1.team && $0.fullName < $1.fullName) }
            : sorted { $0.team > $1.team || ($0.team == $1.team && $0.fullName < $1.fullName) }
            
        case .employeeType:
            return option == .ascending
            ? sorted { $0.employeeType.rawValue < $1.employeeType.rawValue || ($0.employeeType.rawValue == $1.employeeType.rawValue && $0.fullName < $1.fullName) }
            : sorted { $0.employeeType.rawValue > $1.employeeType.rawValue || ($0.employeeType.rawValue == $1.employeeType.rawValue && $0.fullName < $1.fullName) }
        }
    }
}