```swift
import Foundation
import HealthKit

public struct HealthSession: Codable {

  public let start: Date
  public let finish: Date

  public init(start: Date, finish: Date) {

    self.start = start
    self.finish = finish
  }
}

public protocol HealthStore: class {

  var hasAccess: Bool { get }

  func requestAccess(completion: (@escaping (Result<Bool, Error>) -> Void))

  func save(session: HealthSession, completion: (@escaping (Result<Bool, Error>) -> Void))

  func loadSessions(completion: (@escaping (Result<[HealthSession], Error>) -> Void))

  func calculateMindfulMinutes(completion: @escaping ((Result<Double, Error>) -> Void))

}

class LocalHealthStore: HealthStore {

  private let store: HKHealthStore

  private let accessType: HKCategoryType = .categoryType(forIdentifier: .mindfulSession)!

  private init() {
    self.store = HKHealthStore()
  }

  static let shared = LocalHealthStore()

  var hasAccess: Bool {

    let status = store.authorizationStatus(for: accessType)

    switch status {
    case .sharingAuthorized:
      return true
    case .sharingDenied:
      return false
    default:
      return false
    }
  }

  func requestAccess(completion: @escaping ((Result<Bool, Error>) -> Void)) {

    store.requestAuthorization(toShare: [accessType], read: [accessType]) { (success, error) in

      DispatchQueue.main.async {
        if success {
          completion(.success(true))
        } else {
          completion(.failure(error!))
        }
      }
    }

  }

  func save(session: HealthSession, completion: @escaping ((Result<Bool, Error>) -> Void)) {

    guard hasAccess else { return }

    let sample  = HKCategorySample(type: accessType, value: 0, start: session.start, end: session.finish)

    store.save(sample) { (success, error) in
      DispatchQueue.main.async {
        if success {
          completion(.success(true))
        }  else {
          completion(.failure(error!))
        }
      }
    }
  }

  func loadSessions(completion: @escaping ((Result<[HealthSession], Error>) -> Void)) {

    guard hasAccess else { return }

    let endDate = Date()
    let startDate = Date().startOfDay

    let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: [])

    let sortDescriptor = NSSortDescriptor (key: HKSampleSortIdentifierEndDate, ascending: false)

    let query = HKSampleQuery (
      sampleType: accessType,
      predicate: predicate,
      limit: 100,
      sortDescriptors: [sortDescriptor],
      resultsHandler: { self.handleResults(query: $0, samples: $1, error: $2, completion: completion)})

    store.execute(query)

  }

  func handleResults(query: HKSampleQuery, samples: [HKSample]?, error: Error?, completion: @escaping (Result<[HealthSession], Error>) -> Void) {

    DispatchQueue.main.async {
      if let error = error {
        completion(.failure(error))

        return
      }

      let sessions = (samples ?? []).map {HealthSession(start: $0.startDate, finish: $0.endDate) }

      completion(.success(sessions))
    }
  }

  func calculateMindfulMinutes(completion: @escaping ((Result<Double, Error>) -> Void)) {

    loadSessions { result in
      do {

        let sessions = try result.get()

        let mindfulMinutes = sessions.reduce(0.0) { totalMinutes, session in

         let secondsForSession = session.finish.timeIntervalSince(session.start)

          let minutesForSession = secondsForSession / 60

          return minutesForSession + totalMinutes
        }

        completion(.success(mindfulMinutes))
      } catch {
        completion(.failure(error))
      }
    }
  }

}

extension Date {
  var startOfDay: Date {
    return Calendar.current.startOfDay(for: self)
  }
}
```