//
//  Helper.swift
//  VDSSample
//
//  Created by Matt Bruce on 11/18/22.
//

import Foundation
import VDS
import UIKit

extension UIView {
    
    public class ViewConstraints {
        public var topConstraint: NSLayoutConstraint?
        public var leadingConstraint: NSLayoutConstraint?
        public var trailingConstraint: NSLayoutConstraint?
        public var bottomConstraint: NSLayoutConstraint?
        public weak var view: UIView?
        public var allConstraints: [NSLayoutConstraint] {
            [topConstraint, leadingConstraint, trailingConstraint, bottomConstraint].compactMap{ $0 }
        }
        
        public var isActive: Bool = true {
            didSet {
                allConstraints.forEach { $0.isActive = isActive }
            }
        }
        
        public init(view: UIView){
            self.view = view
        }
        
        public func removeConstraint(edges: [UIRectEdge]) {
            edges.forEach { edge in
                switch edge {
                case .all:
                    if let leadingConstraint {
                        view?.removeConstraint(leadingConstraint)
                    }
                    if let trailingConstraint {
                        view?.removeConstraint(trailingConstraint)
                    }
                    if let topConstraint {
                        view?.removeConstraint(topConstraint)
                    }
                    if let bottomConstraint {
                        view?.removeConstraint(bottomConstraint)
                    }                    
                case .left:
                    if let leadingConstraint {
                        view?.removeConstraint(leadingConstraint)
                    }
                case .right:
                    if let trailingConstraint {
                        view?.removeConstraint(trailingConstraint)
                    }
                case .top:
                    if let topConstraint {
                        view?.removeConstraint(topConstraint)
                    }
                case .bottom:
                    if let bottomConstraint {
                        view?.removeConstraint(bottomConstraint)
                    }
                default:
                    break
                }
            }
        }
    }

    public static func makeWrapper(for view: UIView, edgeSpacing: CGFloat = 0.0, isTrailing: Bool = true) -> UIView {
        return makeWrappedView(for: view, edgeSpacing: edgeSpacing, isTrailing: isTrailing).view
    }
    
    public class WrappedViewHelper {
        public var view: UIView
        public var constraints: ViewConstraints
        
        var viewPadding: CGFloat = 0 {
            didSet {
                constraints.topConstraint?.constant = viewPadding
                constraints.leadingConstraint?.constant = viewPadding
                constraints.trailingConstraint?.constant = -viewPadding
                constraints.bottomConstraint?.constant = -viewPadding
            }
        }
        
        public init(view: UIView, constraints: ViewConstraints) {
            self.view = view
            self.constraints = constraints
        }
    }
    
    public static func makeWrappedView(for view: UIView, edgeSpacing: CGFloat = 0.0, isTrailing: Bool = true) -> WrappedViewHelper {
        let wrapper = UIView().with {
            $0.translatesAutoresizingMaskIntoConstraints = false
        }
        wrapper.addSubview(view)
        let constraints = view.addConstraints(to: wrapper, edgeSpacing: edgeSpacing, isTrailing: isTrailing)
        return WrappedViewHelper(view: wrapper, constraints: constraints)
    }
    
    public func addConstraints(to view: UIView, edgeSpacing: CGFloat = 0.0, isTrailing: Bool = true) -> ViewConstraints {
        let constraints = ViewConstraints(view: self)
        constraints.topConstraint = topAnchor.constraint(equalTo: view.topAnchor)
        constraints.bottomConstraint = bottomAnchor.constraint(equalTo: view.bottomAnchor)

        if isTrailing {
            constraints.leadingConstraint = leadingAnchor.constraint(equalTo: view.leadingAnchor)
            constraints.trailingConstraint = trailingAnchor.constraint(lessThanOrEqualTo: view.trailingAnchor)
            
        } else {
            constraints.leadingConstraint = leadingAnchor.constraint(equalTo: view.leadingAnchor)
            constraints.trailingConstraint = trailingAnchor.constraint(equalTo: view.trailingAnchor)
        }
        constraints.isActive = true
        return constraints
    }    
}

extension ButtonBase {
    func labelPublisher(_ label: UILabel){
        onClick = { control in
            let newText = "\(control.text!) clicked - "
            if let labelText = label.text {
                let components = labelText.components(separatedBy: " - ")
                let last: String = (components.last ?? "0").trimmingCharacters(in: .whitespaces)
                let count = Int(last)!
                label.text = "\(newText)\(count+1)"
            } else {
                label.text = "\(newText)1"
            }
            print("clicked me")
        }
    }
}

extension BaseViewController {
    func makeButton(_ text: String, label: UILabel) -> Button {
        return Button().with{
            $0.text = text
            $0.labelPublisher(label)
        }
    }
    
    func makeTextLink(_ text: String, label: UILabel) -> TextLink {
        return TextLink().with{
            $0.text = text
            $0.labelPublisher(label)
        }
    }
    
    func makeTextLinkCaret(_ text: String, label: UILabel) -> TextLinkCaret {
        return TextLinkCaret().with{
            $0.text = text
            $0.labelPublisher(label)
        }
    }
}