import UIKit
import Photos

class ImageZoomViewController: UIViewController, UIScrollViewDelegate {

    // 전화면에서 받아올 asset 프로퍼티
    var asset: PHAsset!
    // imageManager를 통해 이미지 요청
    let imageManager: PHCachingImageManager = PHCachingImageManager()

    @IBOutlet weak var imageView: UIImageView!

    // scrollView delegate 메서드
    func viewForZooming(in scrollView: UIScrollView) -> UIView? {
        // scrollview가 줌을 해줄 대상이 누구? = imageView
        return self.imageView
    }
    override func viewDidLoad() {
        super.viewDidLoad()
        // 메모리에 화면이 로드가 되면 호출될 이미지의 사이즈 등..
        imageManager.requestImage(for: asset, targetSize: CGSize(width: asset.pixelWidth, height: asset.pixelHeight), contentMode: .aspectFill, options: nil, resultHandler: { image, _ in self.imageView.image = image})

        // Do any additional setup after loading the view.
    }
}

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    guard let nextViewController: ImageZoomViewController = segue.destination as? ImageZoomViewController else { return }
    guard let cell: UITableViewCell = sender as? UITableViewCell else { return }
    guard let index: IndexPath = self.tableView.indexPath(for: cell) else { return }
    nextViewController.asset = self.fetchResult[index.row]
}

weak var delegate: UIScrollViewDelegate? { get set }​

var contentSize: CGSize { get set }

var contentOffset: CGPoint { get set }

// setContentOffset(_:animated:) : 스크롤뷰의 원점에 대한 콘텐츠뷰의 오프셋 설정
func setContentOffset(_ contentOffset: CGPoint, animated: Bool)

var contentInset: UIEdgeInsets { get set }​

// isScrollEnabled : 스크롤링이 사용 가능한지 아닌지를 결정하는 부울 값
var isScrollEnabled: Bool { get set }​

// isDirectionalLockEnabled : 스크롤이 특정 방향으로 고정할지를 결정하는 부울 값
var isDirectionalLockEnabled: Bool { get set }

//isPagingEnabled : 스크롤뷰에서 페이징을 사용할 수 있는 여부를 결정하는 부울 값
var isPagingEnabled: Bool { get set }

//scrollsToTop :  스크롤 할 수 있는 제스처를 사용할지를 결정하는 부울 값
var scrollsToTop: Bool { get set }

// bounces : 스크롤뷰가 가장자리를 통과해서 다시 튀어나오는지 제어하는 부울 값
var bounces: Bool { get set }

// alwaysBounceVertical : 세로 스크롤이 콘텐츠뷰의 끝에 도달할 때 튀어 오르기가 항상 발생하는지를 결정하는 부울 값
var alwaysBounceVertical: Bool { get set }

// alwaysBounceHorizontal : 가로 스크롤이 콘텐츠뷰의 끝에 도달할 때 튀어 오르기가 항상 발생하는지를 결정하는 부울 값
var alwaysBounceHorizontal: Bool { get set }

// isTracking : 사용자가 스크롤을 시작하기 위해 콘텐츠를 터치한 여부를 반환
var isTracking: Bool { get }

// isDragging : 사용자가 콘텐츠를 스크롤하고 있는지 나타내는 부울 값
var isDragging: Bool { get }

// isDecelerating : 사용자가 손가락을 떼었을 때 콘텐츠가 스크롤뷰에서 움직이지 않고 있는지를 반환
var isDecelerating: Bool { get }

// decelerationRate : 사용자가 손가락을 뗀 후의 감속도를 결정하는 부동 소수점 값
var decelerationRate: CGFloat { get set }

// indicatorStyle : 스크롤 인디케이터의 스타일
var indicatorStyle: UIScrollViewIndicatorStyle { get set }

// showsHorizontalScrollIndicator : 가로 스크롤 바 표시 여부를 제어하는 부울 값
var showsHorizontalScrollIndicator: Bool { get set }

// showsVerticalScrollIndicator : 세로 스크롤 바 표시 여부를 제어하는 부울 값
var showsVerticalScrollIndicator: Bool { get set }

// scrollRectToVisible(_:animated:) : 콘텐츠의 특정 위치로 스크롤 하여 화면에 표시
func scrollRectToVisible(_ rect: CGRect,  animated: Bool)

// panGestureRecognizer : 팬 제스처를 제어하기 위한 제스처 인스턴스
var panGestureRecognizer: UIPanGestureRecognizer { get }

// pinchGestureRecognizer : 핀치 제스처를 제어하기 위한 제스처 인스턴스
var pinchGestureRecognizer: UIPinchGestureRecognizer? { get }

// zoomScale : 스크롤뷰 콘텐츠에 적용되는 현재 배율
var zoomScale: CGFloat { get set }

// maximumZoomScale :  스크롤뷰 콘텐츠에 적용되는 최대 배율
var maximumZoomScale: CGFloat { get set }

// minimumZoomScale : 스크롤뷰 콘텐츠에 적용되는 최소 배율
var minimumZoomScale: CGFloat { get set }

// isZoomBouncing : 확대 및 축소가 지정한 배율 제한을 초과했음을 나타내는 부울 값
var isZoomBouncing: Bool { get }

// isZooming : 콘텐츠뷰가 현재 확대 또는 축소되어 있는지를 나타내는 부울 값
var isZooming: Bool { get }

// bouncesZoom : 크기 조정이 최대 또는 최소 제한을 초과할 때 튀어 오르는 애니메이션을 보여줄지 결정하는 부울 값
var bouncesZoom: Bool { get set }

// zoom(to:animated:) : 콘텐츠 특정 영역 확대
func zoom(to rect: CGRect, animated: Bool)

// setZoomScale(_:animated:) : 현재 배율을 지정
func setZoomScale(_ scale: CGFloat, animated: Bool)

// keyboardDismissMode : 스크롤뷰에서 드래그가 시작될 때 키보드가 해제되는 방식
var keyboardDismissMode: UIScrollViewKeyboardDismissMode { get set }

// scrollViewDidScroll(_:) : 콘텐츠뷰를 스크롤 할 때 델리게이트에 알림
optional func scrollViewDidScroll(_ scrollView: UIScrollView)

// scrollViewWillBeginDragging(_:) : 스크롤뷰에서 콘텐츠 스크롤을 시작할 시점을 델리게이트에 알림
optional func scrollViewWillBeginDragging(_ scrollView: UIScrollView)

// scrollViewWillEndDragging(_:withVelocity:targetContentOffset:) : 스크롤뷰의 드래그가 끝나기 직전에 델리게이트에 알림
optional func scrollViewWillEndDragging(_ scrollView: UIScrollView,
                        withVelocity velocity: CGPoint,
                 targetContentOffset: UnsafeMutablePointer<CGPoint>)

// scrollViewDidEndDragging(_:willDecelerate:) : 스크롤뷰의 드래그가 끝났을 때 델리게이트에 알림
optional func scrollViewDidEndDragging(_ scrollView: UIScrollView,
                     willDecelerate decelerate: Bool)

// scrollViewShouldScrollToTop(_:) : 스크롤뷰가 콘텐츠의 맨 위로 스크롤 해야 하는 경우 델리게이트에 동작 여부를 물어봄
optional func scrollViewShouldScrollToTop(_ scrollView: UIScrollView) -> Bool

// scrollViewDidScrollToTop(_:) : 스크롤뷰가 콘텐츠의 맨 위로 스크롤 되었음을 델리게이트에 알림
optional func scrollViewDidScrollToTop(_ scrollView: UIScrollView)

// scrollViewWillBeginDecelerating(_:) : 스크롤링 동작이 감속되기 시작하고 있다고 델리게이트에 알림
optional func scrollViewWillBeginDecelerating(_ scrollView: UIScrollView)

// scrollViewDidEndDecelerating(_:) : 스크롤링 동작이 감속이 끝났을 때 델리게이트에 알림

// optional func scrollViewDidEndDecelerating(_ scrollView: UIScrollView)

//viewForZooming(in:) : 스크롤뷰에서 확대 및 축소를 할 때 확대 및 축소를 할 뷰 인스턴스를 요청
optional func viewForZooming(in scrollView: UIScrollView) -> UIView?

// scrollViewWillBeginZooming(_:with:) : 스크롤뷰의 콘텐츠 확대가 시작될 때 델리게이트에 알림
optional func scrollViewWillBeginZooming(_ scrollView: UIScrollView,
                                 with view: UIView?)

// scrollViewDidEndZooming(_:with:atScale:) : 스크롤뷰의 콘텐츠 확대가 완료될 때 델리게이트에 알림
optional func scrollViewDidEndZooming(_ scrollView: UIScrollView,
                              with view: UIView?,
                           atScale scale: CGFloat)

// scrollViewDidZoom(_:) : 스크롤뷰의 확대 및 축소 배율이 변경될 때 델리게이트에 알림
optional func scrollViewDidZoom(_ scrollView: UIScrollView)

scrollViewDidEndScrollingAnimation(_:) : 스크롤뷰의 스크롤 애니메이션이 끝날 때 델리게이트에 알림
optional func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView)

import UIKit
import Photos

class ViewController: UIViewController, UITableViewDataSource {

    // 사진 목록을 테이블뷰에 보여줄 것
    @IBOutlet weak var tableView: UITableView!
    var fetchResult: PHFetchResult<PHAsset>!
    // 가져온 에셋을 가지고 이미지를 로드해옴
    let imageManager: PHCachingImageManager = PHCachingImageManager()
    let cellIdentifier: String = "cell"

    func requestCollection() {
        // 사진찍으면 사진이 저장되는 카메라롤의 컬렉션을 가져옴
        let cameraRoll: PHFetchResult<PHAssetCollection> = PHAssetCollection.fetchAssetCollections(with: .smartAlbum, subtype: .smartAlbumUserLibrary, options: nil)

        guard let cameraRollColletction = cameraRoll.firstObject else {
            return
        }
        let fetchOptions = PHFetchOptions()
        // 최신순으로 사진을 sort
        fetchOptions.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]
        // 그 결과를 fetchResult라는 프로퍼티로 가져옴
        self.fetchResult = PHAsset.fetchAssets(in: cameraRollColletction, options: fetchOptions)
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
        let photoAuthorizationStatus = PHPhotoLibrary.authorizationStatus()

        switch photoAuthorizationStatus {
        case .authorized:
            print("접근 허가됨")
            self.requestCollection()
            self.tableView.reloadData()
        case .denied:
            print("접근 불허")
        case .notDetermined:
            print("아직 응답하지 않음")
            PHPhotoLibrary.requestAuthorization({ (status) in
                switch status {
                case .authorized:
                    print("사용자가 허용함")
                    self.requestCollection()
                    self.tableView.reloadData()
                case .denied:
                    print("사용자가 불허함")
                default: break
                }
            })
        case .restricted:
            print("접근 제한")
        }
    }
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return self.fetchResult?.count ?? 0
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        // cell에 이미지를 하나씩 넣어줌
        let cell: UITableViewCell = tableView.dequeueReusableCell(withIdentifier: self.cellIdentifier, for: indexPath)
        // asset은 fetchresult에서 index에 해당
        let asset: PHAsset = fetchResult.object(at: indexPath.row)
        // imageManager를 통해 실질적인 이미지를 요청
        imageManager.requestImage(for: asset, targetSize: CGSize(width: 30, height: 30), contentMode: .aspectFill, options: nil, resultHandler: { image, _ in cell.imageView?.image = image})
        return cell
    }
}

override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view.
    let photoAuthorizationStatus = PHPhotoLibrary.authorizationStatus()

    switch photoAuthorizationStatus {
    case .authorized:
        print("접근 허가됨")
        self.requestCollection()
        self.tableView.reloadData()
    case .denied:
        print("접근 불허")
    case .notDetermined:
        print("아직 응답하지 않음")
        PHPhotoLibrary.requestAuthorization({ (status) in
            switch status {
            case .authorized:
                print("사용자가 허용함")
                self.requestCollection()
                OperationQueue.main.addOperation {
                    self.tableView.reloadData()
                }
            case .denied:
                print("사용자가 불허함")
            default: break
            }
        })
    case .restricted:
        print("접근 제한")
    }
}

import UIKit
import Photos

class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, PHPhotoLibraryChangeObserver {
    // PHphotoobserver는 library에 변화가 생기면 감지를 하는 프로토콜

    // 사진 목록을 테이블뷰에 보여줄 것
    @IBOutlet weak var tableView: UITableView!
    var fetchResult: PHFetchResult<PHAsset>!
    // 가져온 에셋을 가지고 이미지를 로드해옴
    let imageManager: PHCachingImageManager = PHCachingImageManager()
    let cellIdentifier: String = "cell"

    func requestCollection() {
        // 사진찍으면 사진이 저장되는 카메라롤의 컬렉션을 가져옴
        let cameraRoll: PHFetchResult<PHAssetCollection> = PHAssetCollection.fetchAssetCollections(with: .smartAlbum, subtype: .smartAlbumUserLibrary, options: nil)

        guard let cameraRollColletction = cameraRoll.firstObject else {
            return
        }
        let fetchOptions = PHFetchOptions()
        // 최신순으로 사진을 sort
        fetchOptions.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]
        // 그 결과를 fetchResult라는 프로퍼티로 가져옴
        self.fetchResult = PHAsset.fetchAssets(in: cameraRollColletction, options: fetchOptions)
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
        let photoAuthorizationStatus = PHPhotoLibrary.authorizationStatus()

        switch photoAuthorizationStatus {
        case .authorized:
            print("접근 허가됨")
            self.requestCollection()
            self.tableView.reloadData()
        case .denied:
            print("접근 불허")
        case .notDetermined:
            print("아직 응답하지 않음")
            PHPhotoLibrary.requestAuthorization({ (status) in
                switch status {
                case .authorized:
                    print("사용자가 허용함")
                    self.requestCollection()
                    OperationQueue.main.addOperation {
                        self.tableView.reloadData()
                    }
                case .denied:
                    print("사용자가 불허함")
                default: break
                }
            })
        case .restricted:
            print("접근 제한")
        }
        // 아래 한줄을 써줌으로써 photoLibrary가 변화될때마다 delegate메서드가 호출됨
        PHPhotoLibrary.shared().register(self)
    }

    func tableView(_ tableView: UITableView, canEditRowAt indexPath: IndexPath) -> Bool {  // row를 편집할수 있게 해주는 메서드, tableview row를 밀어서 삭제하는 행위를 가능하게 함
        return true
    }

    func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
        // 삭제 모드로 들어왔을때(편집을 하려할때)
        if editingStyle == .delete { // 삭제라면 asset을 가지고 delete를 하면
            let asset: PHAsset = self.fetchResult[indexPath.row]
        PHPhotoLibrary.shared().performChanges({PHAssetChangeRequest.deleteAssets([asset] as NSArray)}, completionHandler: nil)
            // 실제 삭제를 하게되면 나오게 되는 팝업창
        }
    }

    func photoLibraryDidChange(_ changeInstance: PHChange) {
        // observer 프로토콜을 따른 메서드

        guard let changes = changeInstance.changeDetails(for: fetchResult) else {
            return
        }
        // 어떤게 바꼈는지
        fetchResult = changes.fetchResultAfterChanges
        // 바꼈다면 tableview를 다시 불러달라
        OperationQueue.main.addOperation {
            self.tableView.reloadSections(IndexSet(0...0), with: .automatic)
        }
    }
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return self.fetchResult?.count ?? 0
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        // cell에 이미지를 하나씩 넣어줌
        let cell: UITableViewCell = tableView.dequeueReusableCell(withIdentifier: self.cellIdentifier, for: indexPath)
        // asset은 fetchresult에서 index에 해당
        let asset: PHAsset = fetchResult.object(at: indexPath.row)
        // imageManager를 통해 실질적인 이미지를 요청
        imageManager.requestImage(for: asset, targetSize: CGSize(width: 30, height: 30), contentMode: .aspectFill, options: nil, resultHandler: { image, _ in cell.imageView?.image = image})
        return cell
    }
}