//
//  EmptyDataSet.swift
//  EmptyDataSet-Swift
//
//  Created by YZF on 28/6/17.
//  Copyright © 2017年 Xiaoye. All rights reserved.
//

import Foundation
import UIKit

class WeakObjectContainer: NSObject {
    weak var weakObject: AnyObject?
    
    init(with weakObject: Any?) {
        super.init()
        self.weakObject = weakObject as AnyObject?
    }
}

extension UIScrollView: UIGestureRecognizerDelegate {
    
    struct Key {
        static var kEmptyDataSetSource =           "emptyDataSetSource"
        static var kEmptyDataSetDelegate =         "emptyDataSetDelegate"
        static var kEmptyDataSetView =             "emptyDataSetView"
        static var kConfigureEmptyDataSetView =    "configureEmptyDataSetView"
    }
    
    private var configureEmptyDataSetView: ((EmptyDataSetView) -> Void)? {
        get {
            return objc_getAssociatedObject(self, &Key.kConfigureEmptyDataSetView) as? (EmptyDataSetView) -> Void
        }
        set {
            objc_setAssociatedObject(self, &Key.kConfigureEmptyDataSetView, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            UIScrollView.swizzleReloadData
            if self is UITableView {
                UIScrollView.swizzleEndUpdates
            }
        }
    }
    
    //MARK: - Public Property
    public var emptyDataSetSource: EmptyDataSetSource? {
        get {
            let container = objc_getAssociatedObject(self, &Key.kEmptyDataSetSource) as? WeakObjectContainer
            return container?.weakObject as? EmptyDataSetSource
        }
        set {
            if newValue == nil {
                self.invalidate()
            }

            objc_setAssociatedObject(self, &Key.kEmptyDataSetSource, WeakObjectContainer(with: newValue), .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            UIScrollView.swizzleReloadData
            if self is UITableView {
                UIScrollView.swizzleEndUpdates
            }
        }
    }
    
    public var emptyDataSetDelegate: EmptyDataSetDelegate? {
        get {
            let container = objc_getAssociatedObject(self, &Key.kEmptyDataSetDelegate) as? WeakObjectContainer
            return container?.weakObject as? EmptyDataSetDelegate
        }
        set {
            if newValue == nil {
                self.invalidate()
            }
            objc_setAssociatedObject(self, &Key.kEmptyDataSetDelegate, WeakObjectContainer(with: newValue), .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }
    
    public var isEmptyDataSetVisible: Bool {
        if let view = objc_getAssociatedObject(self, &Key.kEmptyDataSetView) as? EmptyDataSetView {
            return !view.isHidden
        }
        return false
    }
    
    //MARK: - privateProperty
    public func emptyDataSetView(_ closure: @escaping (EmptyDataSetView) -> Void) {
        configureEmptyDataSetView = closure
    }
    
    private var emptyDataSetView: EmptyDataSetView? {
        get {
            if let view = objc_getAssociatedObject(self, &Key.kEmptyDataSetView) as? EmptyDataSetView {
                return view
            } else {
                let view = EmptyDataSetView.init(frame: frame)
                view.autoresizingMask = [.flexibleHeight, .flexibleWidth]
                view.isHidden = true
                let tapGesture = UITapGestureRecognizer.init(target: self, action: #selector(didTapContentView(_:)))
                tapGesture.delegate = self
                view.addGestureRecognizer(tapGesture)
                view.button.addTarget(self, action: #selector(didTapDataButton(_:)), for: .touchUpInside)

                objc_setAssociatedObject(self, &Key.kEmptyDataSetView, view, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
                
                return view
            }
        }
        set {
            objc_setAssociatedObject(self, &Key.kEmptyDataSetView, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC);
        }
    }
    
    internal var itemsCount: Int {
        var items = 0
        
        // UITableView support
        if let tableView = self as? UITableView {
            var sections = 1
            
            if let dataSource = tableView.dataSource {
                if dataSource.responds(to: #selector(UITableViewDataSource.numberOfSections(in:))) {
                    sections = dataSource.numberOfSections!(in: tableView)
                }
                if dataSource.responds(to: #selector(UITableViewDataSource.tableView(_:numberOfRowsInSection:))) {
                    for i in 0 ..< sections {
                        items += dataSource.tableView(tableView, numberOfRowsInSection: i)
                    }
                }
            }
        } else if let collectionView = self as? UICollectionView {
            var sections = 1
            
            if let dataSource = collectionView.dataSource {
                if dataSource.responds(to: #selector(UICollectionViewDataSource.numberOfSections(in:))) {
                    sections = dataSource.numberOfSections!(in: collectionView)
                }
                if dataSource.responds(to: #selector(UICollectionViewDataSource.collectionView(_:numberOfItemsInSection:))) {
                    for i in 0 ..< sections {
                        items += dataSource.collectionView(collectionView, numberOfItemsInSection: i)
                    }
                }
            }
        }
        
        return items
    }
    
    //MARK: - Data Source Getters
    private var titleLabelString: NSAttributedString? {
        return emptyDataSetSource?.title(forEmptyDataSet: self)
    }
    
    private var detailLabelString: NSAttributedString? {
        return emptyDataSetSource?.description(forEmptyDataSet: self)
    }
    
    private var image: UIImage? {
        return emptyDataSetSource?.image(forEmptyDataSet: self)
    }
    
    private var imageAnimation: CAAnimation? {
        return emptyDataSetSource?.imageAnimation(forEmptyDataSet: self)
    }
    
    private var imageTintColor: UIColor? {
        return emptyDataSetSource?.imageTintColor(forEmptyDataSet: self)
    }
    
    private func buttonTitle(for state: UIControl.State) -> String? {
        return emptyDataSetSource?.buttonTitle(forEmptyDataSet: self, for: state)
    }
    
    private func buttonAttributedTitle(for state: UIControl.State) -> NSAttributedString? {
        return emptyDataSetSource?.buttonAttributedTitle(forEmptyDataSet: self, for: state)
    }
    
    private func buttonImage(for state: UIControl.State) -> UIImage? {
        return emptyDataSetSource?.buttonImage(forEmptyDataSet: self, for: state)
    }
    
    private func buttonBackgroundImage(for state: UIControl.State) -> UIImage? {
        return emptyDataSetSource?.buttonBackgroundImage(forEmptyDataSet: self, for: state)
    }
    
    private var dataSetBackgroundColor: UIColor? {
        return emptyDataSetSource?.backgroundColor(forEmptyDataSet: self)
    }
    
    private var customView: UIView? {
        return emptyDataSetSource?.customView(forEmptyDataSet: self)
    }
    
    private var verticalOffset: CGFloat {
        return emptyDataSetSource?.verticalOffset(forEmptyDataSet: self) ?? 0.0
    }
    
    private var verticalSpace: CGFloat {
        return emptyDataSetSource?.spaceHeight(forEmptyDataSet: self) ?? 0.0
    }
    
    //MARK: - Delegate Getters & Events (Private)
    
    private var shouldFadeIn: Bool {
        return emptyDataSetDelegate?.emptyDataSetShouldFadeIn(self) ?? true
    }
    
    private var shouldDisplay: Bool {
        return emptyDataSetDelegate?.emptyDataSetShouldDisplay(self) ?? true
    }
    
    private var shouldBeForcedToDisplay: Bool {
        return emptyDataSetDelegate?.emptyDataSetShouldBeForcedToDisplay(self) ?? false
    }
    
    private var isTouchAllowed: Bool {
        return emptyDataSetDelegate?.emptyDataSetShouldAllowTouch(self) ?? true
    }
    
    private var isScrollAllowed: Bool {
        return emptyDataSetDelegate?.emptyDataSetShouldAllowScroll(self) ?? false
    }
    
    private var isImageViewAnimateAllowed: Bool {
        return emptyDataSetDelegate?.emptyDataSetShouldAnimateImageView(self) ?? true
    }
    
    private func willAppear() {
        emptyDataSetDelegate?.emptyDataSetWillAppear(self)
        emptyDataSetView?.willAppearHandle?()
    }
    
    private func didAppear() {
        emptyDataSetDelegate?.emptyDataSetDidAppear(self)
        emptyDataSetView?.didAppearHandle?()
    }
    
    private func willDisappear() {
        emptyDataSetDelegate?.emptyDataSetWillDisappear(self)
        emptyDataSetView?.willDisappearHandle?()
    }
    
    private func didDisappear() {
        emptyDataSetDelegate?.emptyDataSetDidDisappear(self)
        emptyDataSetView?.didDisappearHandle?()
    }
    
    @objc private func didTapContentView(_ sender: UITapGestureRecognizer) {
        guard let view = sender.view else { return }
        emptyDataSetDelegate?.emptyDataSet(self, didTapView: view)
        emptyDataSetView?.didTapContentViewHandle?()
    }
    
    @objc private func didTapDataButton(_ sender: UIButton) {
        emptyDataSetDelegate?.emptyDataSet(self, didTapButton: sender)
        emptyDataSetView?.didTapDataButtonHandle?()
    }
    
    //MARK: - Reload APIs (Public)
    public func reloadEmptyDataSet() {
        guard (emptyDataSetSource != nil || configureEmptyDataSetView != nil) else {
            return
        }
        
        if (shouldDisplay && itemsCount == 0) || shouldBeForcedToDisplay {
            // Notifies that the empty dataset view will appear
            willAppear()
            
            if let view = emptyDataSetView {
                
                // Configure empty dataset fade in display
                view.fadeInOnDisplay = shouldFadeIn
                
                if view.superview == nil {
                    // Send the view all the way to the back, in case a header and/or footer is present, as well as for sectionHeaders or any other content
                    if (self is UITableView) || (self is UICollectionView) || (subviews.count > 1) {
                        insertSubview(view, at: 0)
                    } else {
                        addSubview(view)
                    }
                }
                
                // Removing view resetting the view and its constraints it very important to guarantee a good state
                // If a non-nil custom view is available, let's configure it instead
                view.prepareForReuse()
                
                if let customView = self.customView {
                    view.customView = customView
                } else {
                    // Get the data from the data source
                    
                    let renderingMode: UIImage.RenderingMode = imageTintColor != nil ? .alwaysTemplate : .alwaysOriginal
                    
                    view.verticalSpace = verticalSpace
                    
                    // Configure Image
                    if let image = image {
                        view.imageView.image = image.withRenderingMode(renderingMode)
//                        emptyDataSetView.imageView.mj_size.width = image.size.width
//                        emptyDataSetView.imageView.mj_size.height = image.size.height
                        emptyDataSetView?.imageView.layoutChain.size(image.size)
                        if let imageTintColor = imageTintColor {
                            view.imageView.tintColor = imageTintColor
                        }
                    }
                    
                    // Configure title label
                    if let titleLabelString = titleLabelString {
                        view.titleLabel.attributedText = titleLabelString
                    }
                    
                    // Configure detail label
                    if let detailLabelString = detailLabelString {
                        view.detailLabel.attributedText = detailLabelString
                    }
                    
                    // Configure button
                    if let buttonImage = buttonImage(for: .normal) {
                        view.button.setImage(buttonImage, for: .normal)
                        view.button.setImage(self.buttonImage(for: .highlighted), for: .highlighted)
                    }
                    else if let buttonAttributedTitle = buttonAttributedTitle(for: .normal) {
                        view.button.setAttributedTitle(buttonAttributedTitle, for: .normal)
                        view.button.setAttributedTitle(self.buttonAttributedTitle(for: .highlighted), for: .highlighted)
                        view.button.setBackgroundImage(self.buttonBackgroundImage(for: .normal), for: .normal)
                        view.button.setBackgroundImage(self.buttonBackgroundImage(for: .highlighted), for: .highlighted)
                    }
                    else if let buttonTitle = buttonTitle(for: .normal) {
                        view.button.setTitle(buttonTitle, for: .normal)
                        view.button.setTitle(self.buttonTitle(for: .highlighted), for: .highlighted)
                        view.button.setBackgroundImage(self.buttonBackgroundImage(for: .normal), for: .normal)
                        view.button.setBackgroundImage(self.buttonBackgroundImage(for: .highlighted), for: .highlighted)
                    }
                }
                
                // Configure offset
                view.verticalOffset = verticalOffset
                
                // Configure the empty dataset view
                view.backgroundColor = dataSetBackgroundColor
                view.isHidden = false
                view.clipsToBounds = true
                
                // Configure empty dataset userInteraction permission
                view.isUserInteractionEnabled = isTouchAllowed
                
                // Configure scroll permission
                self.isScrollEnabled = isScrollAllowed
                
                // Configure image view animation
                if self.isImageViewAnimateAllowed {
                    if let animation = imageAnimation {
                        view.imageView.layer.add(animation, forKey: nil)
                    }
                } else {
                    view.imageView.layer.removeAllAnimations()
                }
                
                if let config = configureEmptyDataSetView {
                    config(view)
                }
                view.setupViews()
//                view.setupConstraints()
//                view.layoutIfNeeded()
            }
            
            // Notifies that the empty dataset view did appear
            didAppear()
        } else if isEmptyDataSetVisible {
            invalidate()
        }
    }
    
    private func invalidate() {
        willDisappear()
        if let view = emptyDataSetView {
            view.prepareForReuse()
            view.isHidden = true
//            view.removeFromSuperview()
//            emptyDataSetView = nil
        }
        self.isScrollEnabled = true
        didDisappear()
    }
    
    
    //MARK: - Method Swizzling
    @objc private func tableViewSwizzledReloadData() {
        tableViewSwizzledReloadData()
        reloadEmptyDataSet()
    }
    
    @objc private func tableViewSwizzledEndUpdates() {
        tableViewSwizzledEndUpdates()
        reloadEmptyDataSet()
    }
    
    @objc private func collectionViewSwizzledReloadData() {
        collectionViewSwizzledReloadData()
        reloadEmptyDataSet()
    }
    
    private class func swizzleMethod(for aClass: AnyClass, originalSelector: Selector, swizzledSelector: Selector) {
        let originalMethod = class_getInstanceMethod(aClass, originalSelector)
        let swizzledMethod = class_getInstanceMethod(aClass, swizzledSelector)
        
        let didAddMethod = class_addMethod(aClass, originalSelector, method_getImplementation(swizzledMethod!), method_getTypeEncoding(swizzledMethod!))
        
        if didAddMethod {
            class_replaceMethod(aClass, swizzledSelector, method_getImplementation(originalMethod!), method_getTypeEncoding(originalMethod!))
        } else {
            method_exchangeImplementations(originalMethod!, swizzledMethod!)
        }
    }
    
    private static let swizzleReloadData: () = {
//        let tableViewOriginalSelector = #selector(UITableView.reloadData)
//        let tableViewSwizzledSelector = #selector(UIScrollView.tableViewSwizzledReloadData)
//        
//        swizzleMethod(for: UITableView.self, originalSelector: tableViewOriginalSelector, swizzledSelector: tableViewSwizzledSelector)
//        
//        let collectionViewOriginalSelector = #selector(UICollectionView.reloadData)
//        let collectionViewSwizzledSelector = #selector(UIScrollView.collectionViewSwizzledReloadData)
//        
//        swizzleMethod(for: UICollectionView.self, originalSelector: collectionViewOriginalSelector, swizzledSelector: collectionViewSwizzledSelector)
    }()
    
    private static let swizzleEndUpdates: () = {
        let originalSelector = #selector(UITableView.endUpdates)
        let swizzledSelector = #selector(UIScrollView.tableViewSwizzledEndUpdates)
        
        swizzleMethod(for: UITableView.self, originalSelector: originalSelector, swizzledSelector: swizzledSelector)
    }()
}