class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
        // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
        
        guard let windowScene = (scene as? UIWindowScene) else { return }  // Get the window scene
        window = UIWindow(frame: windowScene.coordinateSpace.bounds)  // Create a window
        guard window != nil else { return }
        
        // Assign the window scene to the window's window scene
        window!.windowScene = windowScene
        
        // Set the root view controller (to the nav controller)
        window!.rootViewController = createNavController(with: createInitialViewControler())
        
        // Make the window visible
        window!.makeKeyAndVisible()
    }
    
    :
    :

class CustomTextField: UITextField {
    :
    :
    
    private func config() {
        translatesAutoresizingMaskIntoConstraints = false
        layer.cornerRadius = 10
        layer.borderWidth = 2
        layer.borderColor = UIColor.systemGray4.cgColor
        
        textColor = .label
        tintColor = .label
        textAlignment = .center
        minimumFontSize = 12
        
        backgroundColor = .tertiarySystemBackground
        autocorrectionType = .no
        returnKeyType = .go
        clearButtonMode = .whileEditing
        placeholder = "Search text"
        
        // Support for dynamic type
        font = UIFont.preferredFont(forTextStyle: .title2)
        adjustsFontForContentSizeCategory = true
        adjustsFontSizeToFitWidth = true
    }
}

class CustomGoButton: UIButton {
    :
    :
    
    private func config() {
        layer.cornerRadius = 10
        setTitleColor(.black, for: .normal)  
        
        // Turn constraints OFF as we'll be using auto layout
        translatesAutoresizingMaskIntoConstraints = false  
        
        // Support for dynamic type
        titleLabel?.font = UIFont.preferredFont(forTextStyle: .headline)
        titleLabel?.minimumScaleFactor = 0.5
        titleLabel?.adjustsFontSizeToFitWidth = true
        titleLabel?.adjustsFontForContentSizeCategory = true
    }
}

class SearchViewController: UIViewController {

    let searchTextField = CustomTextField(text: "Puppies")
    let goButton = CustomGoButton(title: "Search")
    
    :
    :
    
    private func configSearchTextField() {
        view.addSubview(searchTextField)
        
        searchTextField.delegate = self
        searchTextField.translatesAutoresizingMaskIntoConstraints = false
        
        NSLayoutConstraint.activate([
            searchTextField.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: UIConstants.padding),
            searchTextField.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: UIConstants.padding),
            searchTextField.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -UIConstants.padding),
            searchTextField.heightAnchor.constraint(equalToConstant: 50)
        ])
    }
    
    private func configGoButton() {
        view.addSubview(goButton)
        goButton.addTarget(self, action: #selector(goButtonTapped), for: .touchUpInside)
        
        NSLayoutConstraint.activate([
            goButton.topAnchor.constraint(equalTo: searchTextField.bottomAnchor, constant: 25),
            goButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            goButton.widthAnchor.constraint(equalToConstant: 200),
            goButton.heightAnchor.constraint(equalToConstant: 50)
        ])
    }
  
    :
    :
}

struct PixabayData: Codable {
    let totalHits: Int
    let hits: [PixabayImage]
    let total: Int
}

struct PixabayImage: Codable, Hashable {
    let largeImageURL: String
    let tags: String
    let previewURL: String
    :
    :
}

func loadImages(searchFor: String, page: Int = 1, completion: @escaping (Result<PixabayData?, NetworkHelperError>) -> Void) {
    :
    :
  
    let task = URLSession.shared.dataTask(with: url) { json, response, error in
    
        :
        :
            
        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        
        // Attempt to decode the JSON as a PixabayData object
        let pixabayData = try? decoder.decode(PixabayData.self, from: json!)
        
        guard pixabayData != nil else {
            completion(.failure(.notDecodable))
            return
        }
        
        DispatchQueue.main.async { completion(.success(pixabayData!)) }
    }
        
  task.resume()
}

struct PropertyFileHelper {
    
    var hasLoadedProperties: Bool { return propertyFile != nil ? true : false }
    private var propertyFile: [String : AnyObject]?

    init(file: String) {
        propertyFile = readPropertyFile(filename: file)
    }
   
    /// Read a property from a dictionary of values that was read from a plist
    func readProperty(key: String) -> String? {
        guard propertyFile != nil else { return nil }
        guard let value = propertyFile![key] as? String else { return nil }
       
        return value
    }
   
    /// Read a plist property file and return a dictionary of values
    func readPropertyFile(filename: String) -> [String : AnyObject]? {
        guard let path = Bundle.main.path(forResource: filename, ofType: "plist") else { return nil }
        guard let contents = NSDictionary(contentsOfFile: path) as? [String : AnyObject] else { return nil }
        
        return contents
    }
}

func configCollectionView() {
    // Set the collectionView to fill our view
    collectionView = UICollectionView(
        frame: view.bounds, collectionViewLayout: CollectionViewHelper.createThreeColumnFlowLayout(in: view))

    view.addSubview(collectionView!)
    collectionView.delegate = self
    collectionView.backgroundColor = .systemBackground
    collectionView.register(PixabayImageCell.self, forCellWithReuseIdentifier: PixabayImageCell.reuseId)
}

func configureDataSource() {
    dataSource = UICollectionViewDiffableDataSource<CollectionViewSection, PixabayImage>(collectionView: collectionView) {
        collectionView, indexPath, data -> UICollectionViewCell? in
            
            let cell = collectionView.dequeueReusableCell(withReuseIdentifier: PixabayImageCell.reuseId, for: indexPath) as! PixabayImageCell
            // Setting the cell's previewImageUrl causes the preview image to be downloaded asynchronously from Pixabay
            cell.previewImageUrl = data.previewURL
            return cell
    }
}

class PixabayImageCell: UICollectionViewCell {
    
    static let reuseId = "PixabayImageCell"

    var previewImageUrl: String = "" {
        didSet {
            guard !previewImageUrl.isEmpty else { return }           
            NetworkHelper.shared.loadImage(from: previewImageUrl) { image in
                guard let image = image else { return }
                self.imageView.image = image
            }
        }
    }
    
    private var imageView = UIImageView()

    :
    :
}

private func getSearchResults() {
    :
    :
    
    NetworkHelper.shared.loadImages(searchFor: searchText!, page: page) { [weak self] result in
        :
        :

        switch result {
        case .failure(let error):
            :
            :
            return

        case .success(let data):
            :
            :
            if self.page == 1 {
                self.imageData = data!.hits
                self.totalImagesAvailable = data!.totalHits
            } else {
                self.imageData.append(contentsOf: data!.hits)
            }
            
            self.getAvailableTags()
            DispatchQueue.main.async { self.updateData() }
            return
        }
    }
}

func updateData() {
    var snapshot = NSDiffableDataSourceSnapshot<CollectionViewSection, PixabayImage>()
    snapshot.appendSections([.main])
    snapshot.appendItems(imageDataIsFiltered ? imageDataFiltered : imageData)
    DispatchQueue.main.async {
        self.dataSource.apply(snapshot, animatingDifferences: true)
        :
        :
    }
}

class DetailViewController: UIViewController {

    var pixabayImage: PixabayImage? {
        didSet {
            guard pixabayImage != nil else { return }
            spinner.startAnimating()
            loading = true
            imageView.imageUrl = pixabayImage!.largeImageURL  // imageLoadComplete(success:) called when image loaded
        }
    }
        
    private var imageView = CustomImageView(frame: .zero)
    :
    :
}
    
protocol CustomImageViewDelegate: class {
    func imageLoadComplete(success: Bool)
}

class CustomImageView: UIImageView {
        
    weak var delegate: CustomImageViewDelegate?
    
    var imageUrl: String? {
        didSet {
            guard let iu = imageUrl else { return }
            NetworkHelper.shared.loadImage(from: iu) { [weak self] img in
                guard let self = self else { return }
                guard let img = img else {
                    DispatchQueue.main.async { self.delegate?.imageLoadComplete(success: false) }
                    return
                }
                    
                self.image = img
                DispatchQueue.main.async { self.delegate?.imageLoadComplete(success: true) }
            }
        }
    }

    :
    :
}