import MKMagneticProgress

class HomeTableViewCell: UITableViewCell {
    @IBOutlet weak var circleProgressBar: MKMagneticProgress!

    override func awakeFromNib() {
        super.awakeFromNib()

        setProgressViewUI()
    }
    
    func setProgressViewUI() {
        circleProgressBar.setProgress(progress: 0)

        circleProgressBar.progressShapeColor = UIColor(named: "7A7BDA")!
        circleProgressBar.backgroundShapeColor = (UIColor(named: "FFFFFF")?.withAlphaComponent(0.1))!
        circleProgressBar.titleColor = UIColor.red
        circleProgressBar.percentColor = UIColor.white
        
        
        circleProgressBar.lineWidth = 16
        circleProgressBar.orientation = .bottom
        circleProgressBar.lineCap = .round
    }
}

import UIKit

class CircleProgressBarView: UIView {
    // 전체 원을 그려줄 layer
    private var circleLayer = CAShapeLayer()
    // 프로그래스 원을 그려줄 layer
    private var progressLayer = CAShapeLayer()
    
    // 원의 시작과 끝을 그려줄 변수 
    private var startPoint = CGFloat(-Double.pi / 2)
    private var endPoint = CGFloat(3 * Double.pi / 2)
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        
        createCirclePath()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
    }

    func createCirclePath() {
        let circlePath = UIBezierPath(arcCenter: CGPoint(x: frame.size.width / 2.0, y: frame.size.height / 2.0), radius: 120, startAngle: startPoint, endAngle: endPoint, clockwise: true)

        // 전체 원 setUI
        circleLayer.path = circlePath.cgPath
        circleLayer.fillColor = UIColor.clear.cgColor
        circleLayer.lineCap = .round
        circleLayer.lineWidth = 10.0
        circleLayer.strokeStart = 0.0
        circleLayer.strokeEnd = 1.0
        circleLayer.strokeColor = UIColor.lightGray.withAlphaComponent(0.2).cgColor
        
        layer.addSublayer(circleLayer)
        
        // 프로그래스 원 UI
        progressLayer.path = circlePath.cgPath
        progressLayer.fillColor = UIColor.clear.cgColor
        progressLayer.lineCap = .round
        progressLayer.lineWidth = 10.0
        progressLayer.strokeStart = 0
        progressLayer.strokeEnd = 0
        progressLayer.strokeColor = UIColor(named: "7A7BDA")?.cgColor
        
        layer.addSublayer(progressLayer)
    
    }

    // 프로그래스 원에 애니메이션을 주고싶다면 사용 
    func progressAnimation(duration: TimeInterval, value: Float, maxValue: Float) {
        let circleProgressAnimation = CABasicAnimation(keyPath: "strokeEnd")
    
        circleProgressAnimation.duration = duration
        circleProgressAnimation.fromValue = 0
        
        progressLayer.strokeStart = 0
        progressLayer.strokeEnd = CGFloat(value/maxValue)
        progressLayer.add(circleProgressAnimation, forKey: "progressAnim")
    }
}

import UIKit
import SnapKit

class ProgressTableViewCell: UITableViewCell {
    @IBOutlet weak var containerView: UIView!
    
    var circleProgressView: CircleProgressBarView!
    var circleDuration: TimeInterval = 2

    var stepData = Int()

    override func awakeFromNib() {
        super.awakeFromNib()

        setupCircleProgressBarView()
    }

    func setupCircleProgressBarView() {
        circleProgressView = CircleProgressBarView()
        self.containerView.addSubview(circleProgressView)

        circleProgressView.snp.makeConstraints { make in
            make.centerX.centerY.equalTo(self.containerView)
            make.top.equalTo(self.containerView).inset(165)
        }
        
        self.circleDuration = 2
        self.circleProgressView.progressAnimation(duration: circleDuration, value: Float(self.stepData), maxValue: 10000)
        
        self.containerView.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.handleTap)))
        self.circleProgressView.layoutIfNeeded()
    }
    
    @objc func handleTap() {
        self.circleDuration = 2
        self.circleProgressView.progressAnimation(duration: circleDuration, value: Float(self.stepData), maxValue: 10000)
    }
}

NSMotionUsageDescription = 걸음수 데이터 측정을 위해 데이터 접근 권한이 필요합니다.

import UIKit
import CoreMotion

class HomeViewController: UIViewController {
    let activityManager = CMMotionActivityManager()
    let pedoMeter = CMPedometer()
    var stepData = 0

    override func viewDidLoad() {
        super.viewDidLoad()
        updateStep()
    }

    func updateStep() {
        if CMPedometer.isStepCountingAvailable() {
            self.pedoMeter.queryPedometerData(from: date.startOfDay(), to: date.endOfDay()) { (date, error) in
                if error == nil {
                    if let response = date {
                        DispatchQueue.main.async {
                            self.stepData = Int(truncating: response.numberOfSteps)
                            
                        }
                    }
                }
            }
        }
    }
}

NSHealthShareUsageDescription = 걸음수 데이터 측정을 위해 데이터 접근 권한이 필요합니다.
NSHealthUpdateUsageDescription = 걸음수 데이터 측정을 위해 데이터 접근 권한이 필요합니다.

import UIKit
import HealthKit

class StepModel: NSObject {
    var step: Double = 0.0
    var date: Date = Date()
    override init() {
        super.init()
    }
    convenience init(step: Double, date: Date) {
        self.init()
        self.step = step
        self.date = date
    }
}

class HomeViewController: UIViewController {
    let healthStore = HKHealthStore()
    
    let typeToShare = HKObjectType.quantityType(forIdentifier: .stepCount)
    let typeToRead = HKObjectType.quantityType(forIdentifier: .stepCount)
    
    var stepDataList: [String] = []
    var stepList: [StepModel] = [StepModel]()

    override func viewDidLoad() {
        super.viewDidLoad()
        configure()
        retrieveData()
    }

    func configure() {
        print("configure")
        if !HKHealthStore.isHealthDataAvailable() {
            setHealthData()
        } else {
            requestAuthorization()
        }
    }
    
    // 권한 요청 
    func requestAuthorization() {
        print("requestAuthorization")
        self.healthStore.requestAuthorization(toShare: Set([typeToShare!]), read: Set([typeToRead!])) { success, error in
            if error != nil {
                print(error?.localizedDescription as Any)
            } else {
                if success {
                    print("권한 승인 완료")
                } else {
                    print("권한 승인 실패")
                }
            }
        }
    }
    
    func setHealthData() {
        print("retrieveData")
        let calender = Calendar.current
        var interval = DateComponents()
        interval.day = 1
        
        var anchorComponents = calender.dateComponents([.day, .month, .year], from: NSDate() as Date)
        anchorComponents.hour = 0
        let anchorDate = calender.date(from: anchorComponents)
        
        let stepQuery = HKStatisticsCollectionQuery(quantityType: HKObjectType.quantityType(forIdentifier: .stepCount)!, quantitySamplePredicate: nil, options: .cumulativeSum, anchorDate: anchorDate!, intervalComponents: interval as DateComponents)
        stepQuery.initialResultsHandler = { query, results, error in
            let endDate = NSDate()
            // 오늘로부터 30일간의 걸음수 데이터를 가져오도록 진행 
            let startDate = calender.date(byAdding: .day, value: -30, to: endDate as Date, wrappingComponents: false)
            if let myResults = results {
                myResults.enumerateStatistics(from: startDate!, to: endDate as Date) { statistics, stop in
                    if let quantity = statistics.sumQuantity() {
                        let date = statistics.startDate
                        let steps = quantity.doubleValue(for: HKUnit.count())
                        self.stepDataList.append("\(date): \(steps)")
                        let model = StepModel(step: steps, date: date)
                        self.stepList.append(model)
                        DispatchQueue.main.async {

                        }
                    }
                }
            }
        }
        healthStore.execute(stepQuery)
    }

    func saveStepCount(stepValue: Int, date: Date, completion: @escaping (Error?) -> Void) {
        guard let stepCountType = HKQuantityType.quantityType(forIdentifier: .stepCount) else { return }
        let stepCountUnit: HKUnit = HKUnit.count()
        let stepCountQuantity = HKQuantity(unit: stepCountUnit, doubleValue: Double(stepValue))
        
        let stepCountSample = HKQuantitySample(type: stepCountType, quantity: stepCountQuantity, start: date, end: date)
        
        self.healthStore.save(stepCountSample) { (success, error) in
            if let error = error {
                completion(error)
                print("Error Saving Steps count Sample: \(error.localizedDescription)")
            } else {
                completion(nil)
                print("Successfully saves step count sample")
            }
        }
    }
}

let hangeul = ["ㄱ","ㄲ","ㄴ","ㄷ","ㄸ","ㄹ","ㅁ","ㅂ","ㅃ","ㅅ","ㅆ","ㅇ","ㅈ","ㅉ","ㅊ","ㅋ","ㅌ","ㅍ","ㅎ"]

func chosungCheck(word: String) -> String {
    var result = ""
    
    for char in word {
        // unicodeScalars: 유니코드 스칼라 값의 모음으로 표현되는 문자열 값
        let octal = char.unicodeScalars[char.unicodeScalars.startIndex].value
        // ~=: 왼쪽에서 정의한 범위 값 안에 오른쪽의 값이 속하면 true, 아니면 false 반환
        if 44032...55203 ~= octal {
            let index = (octal - 0xac00) / 28 / 21
            result = result + hangeul[Int(index)]
        }
    }
    return result
}

func isChosung(word: String) -> Bool {
    var isChosung = false
    for char in word {
        if 0 < hangeul.filter({ $0.contains(char)}).count {
            isChosung = true
        } else {
            isChosung = false
            break
        }
    }
    return isChosung
}

var arr = ["zehye", "hi", "hello", "nice", "to", "meet", "you"]
var filterredArr: [String] = []

extension SearchViewController: UISearchBarDelegate {   
    func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {
        // 텍스트의 공백 제거
        let text = searchText.trimmingCharacters(in: .whitespaces)
        
        // 서치바에 적힌 공백이 제거된 글자의 초성을 체크
        let isChosungCheck = isChosung(word: text)
        
        // filterText라는 상수를 받아 arr를 필터링 합니다.
        // 서치바에서 받은 text에 arr의 초성이 포함되어있는지 여부를 따집니다. 
        let filterText = arr.filter({
            if isChosungCheck {
                return ($0.contains(text) || chosungCheck(word: $0).contains(text))
            } else {
                return $0.contains(text)
            }
        })
        
        // 포함되는 filterText를 filterredArr에 담아주고 
        self.filterredArr = filterText
        // 테이블뷰 리로드를 합니다. 
        self.tableView.reloadData()
    }
    
    // 검색버튼을 눌렀을때도 마찬가지의 로직을 진행합니다. 
    func searchBarSearchButtonClicked(_ searchBar: UISearchBar) {
        
        guard let text = self.searchBar.text?.trimmingCharacters(in: .whitespaces) else { return }
        
        let isChosungCheck = isChosung(word: text)
        
        let filterText = list.filter({
            if isChosungCheck {
                return ($0.contains(text) || chosungCheck(word: $0).contains(text))
            } else {
                return $0.contains(text)
            }
        })
        
        self.filterredArr = filterText
        self.isFiltering = !(self.searchBar.text?.count == 0)
        
        self.tableView.reloadData()
    }
}