//  LoadingLargeImageViewController.swift
//  Tusker
//
//  Created by Shadowfacts on 6/14/19.
//  Copyright © 2019 Shadowfacts. All rights reserved.
//

import UIKit
import Pachyderm

class LoadingLargeImageViewController: UIViewController, LargeImageAnimatableViewController {

    private var attachment: Attachment?
    let url: URL
    let cache: ImageCache
    let imageDescription: String?

    private(set) var loaded = false
    private(set) var largeImageVC: LargeImageViewController?
    private var loadingVC: LoadingViewController?
    
    private var imageRequest: ImageCache.Request?
    
    private var initialControlsVisible: Bool = true
    var controlsVisible: Bool {
        get {
            return largeImageVC?.controlsVisible ?? initialControlsVisible
        }
        set {
            if let largeImageVC = largeImageVC {
                largeImageVC.setControlsVisible(newValue, animated: false)
            } else {
                initialControlsVisible = newValue
            }
        }
    }
    
    var shrinkGestureEnabled = true
    
    weak var animationSourceView: UIImageView?
    var largeImageController: LargeImageViewController? { largeImageVC }
    var animationImage: UIImage? { largeImageVC?.animationImage ?? animationSourceView?.image }
    var animationGifData: Data? { largeImageVC?.animationGifData }
    var dismissInteractionController: LargeImageInteractionController?
    
    override var prefersStatusBarHidden: Bool {
        return true
    }
    override var preferredStatusBarUpdateAnimation: UIStatusBarAnimation {
        return .none
    }
    override var childForHomeIndicatorAutoHidden: UIViewController? {
        return largeImageVC
    }
    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        if UIDevice.current.userInterfaceIdiom == .phone {
            return .allButUpsideDown
        } else {
            return .all
        }
    }
    
    init(url: URL, cache: ImageCache, imageDescription: String?) {
        self.url = url
        self.cache = cache
        self.imageDescription = imageDescription
        
        super.init(nibName: nil, bundle: nil)
        
        modalPresentationStyle = .fullScreen
    }
    
    convenience init(attachment: Attachment) {
        self.init(url: attachment.url, cache: .attachments, imageDescription: attachment.description)
        self.attachment = attachment
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        overrideUserInterfaceStyle = .dark
        view.backgroundColor = .black
        
        if let (data, image) = cache.get(url) {
            createLargeImage(data: data, image: image, url: url)
        } else {
            createPreview()
            
            loadingVC = LoadingViewController()
            embedChild(loadingVC!)
            imageRequest = cache.get(url) { [weak self] (data, image) in
                guard let self = self else { return }
                self.imageRequest = nil
                DispatchQueue.main.async {
                    self.loadingVC?.removeViewAndController()
                    self.createLargeImage(data: data!, image: image!, url: self.url)
                }
            }
        }
        
        if shrinkGestureEnabled {
            dismissInteractionController = LargeImageInteractionController(viewController: self)
        }
    }
    
    override func didMove(toParent parent: UIViewController?) {
        super.didMove(toParent: parent)
        
        if parent == nil {
            imageRequest?.cancel()
        }
    }
    
    private func createLargeImage(data: Data, image: UIImage, url: URL) {
        guard !loaded else { return }
        loaded = true
        
        if let transformedImage = ImageGrayscalifier.convertIfNecessary(url: url, image: image) {
            let gifData = url.pathExtension == "gif" ? data : nil
            createLargeImage(image: transformedImage, gifData: gifData)
        }
    }
    
    private func createLargeImage(image: UIImage, gifData: Data?) {
        let imageView = LargeImageImageContentView(image: image, gifData: gifData)
        
        if let existing = largeImageVC {
            existing.contentView = imageView
        } else {
            largeImageVC = LargeImageViewController(contentView: imageView, description: imageDescription, sourceView: animationSourceView)
            largeImageVC!.initialControlsVisible = initialControlsVisible
            largeImageVC!.shrinkGestureEnabled = false
            embedChild(largeImageVC!)
        }
    }
    
    private func createPreview() {
        guard !self.loaded,
              var image = animationSourceView?.image else { return }
        
        if Preferences.shared.grayscaleImages,
           let source = image.cgImage,
           let grayscale = ImageGrayscalifier.convert(url: nil, cgImage: source) {
            image = grayscale
        }
        self.createLargeImage(image: image, gifData: nil)
    }
    
}