struct SearchScreen: View {
    @State var searchObjects: [SearchObject] = [
        SearchObject(name: "By name", search: { CountryManager.shared.search(byName: $0) }),
        SearchObject(name: "By calling code", search: { CountryManager.shared.search(byCallingCode: $0) }),
        SearchObject(name: "By domain", search: { CountryManager.shared.search(byDomain: $0) }),
        SearchObject(name: "By language", search: { CountryManager.shared.search(byLanguage: $0) })
    ]

    var body: some View {
        ScrollView {
            VStack(alignment: .leading) {
                ForEach(searchObjects.enumerated().map({ $0 }), id: \.element.name, content: { index, searchObject in
                    VStack(alignment: .leading) {
                        Text(searchObject.name)
                            .styleLabel()
                        TextField(searchObject.textFieldName, text: self.$searchObjects[index].text)
                            .styleTitle()
                        self.makeButton(searchObject: self.searchObjects[index])
                    }
                })
            }
        }
    }
}

class SearchObject: ObservableObject {
    let name: String
    let search: (String) -> [Country]
    var text: String = ""

    init(name: String, search: @escaping (String) -> [Country]) {
        self.name = name
        self.search = search
    }
}

self.$searchObjects[index].text

struct SearchScreen: View {
    @State var searchObjects: [SearchObject] = [
        SearchObject(name: "By name", search: { CountryManager.shared.search(byName: $0) }),
        SearchObject(name: "By calling code", search: { CountryManager.shared.search(byCallingCode: $0) }),
        SearchObject(name: "By domain", search: { CountryManager.shared.search(byDomain: $0) }),
        SearchObject(name: "By language", search: { CountryManager.shared.search(byLanguage: $0) })
    ]

    var body: some View {
        ScrollView {
            VStack(alignment: .leading) {
                ForEach(searchObjects.enumerated().map({ $0 }), id: \.element.name, content: { index, searchObject in
                    VStack(alignment: .leading) {
                        Text(searchObject.name)
                            .styleLabel()
                        TextField(searchObject.textFieldName, text: self.$searchObjects[index].text)
                            .styleTitle()
                        self.makeButton(searchObject: self.searchObjects[index])
                    }
                })
            }
        }
    }
}

struct CountriesView: View {
    let countries: [Country]

    var body: some View {
        let withIndex = countries.enumerated().map({ $0 })

        return List(withIndex, id: \.element.name) { index, country in
            NavigationLink(
                destination: CountryView(country: country),
                label: {
                    VStack(alignment: .leading) {
                        Text(country.name)
                            .styleMultiline()
                    }
                    .paddingVertically()
                }
            )
        }
    }
}

.onReceive(store.objectWillChange, perform: {
    DispatchQueue.main.async {
        self.reload()
    }
})

func reload() {
    self.isFavorite = store.isFavorite(country: country)
}

struct CountriesView: View {
    let groups: [Group]

    init(countries: [Country]) {
        self.groups = CountryManager.shared.groups(countries: countries)
    }

    var body: some View {
        List {
            ForEach(groups) { group in
                Section(
                    header:
                        Text(group.initial)
                            .foregroundColor(Color.yellow)
                            .styleTitle(),
                    content: {
                        ForEach(group.countries) { country in
                            CountryRow(country: country)
                        }
                    }
                )
            }
        }
    }
}

func groups(countries: [Country]) -> [Group] {
    let dictionary = Dictionary(grouping: countries, by: { String($0.name.prefix(1)) })
    let groups = dictionary
        .map({ (key: String, value: [Country]) -> Group in
            return Group(initial: key, countries: value)
        })
        .sorted(by: { $0.initial < $1.initial })

    return groups
}

struct BooksScreen: View {
    @ObservedObject var viewModel: BooksViewModel

    var body: some View {
        List {
            ForEach(viewModel.books) { book in
                RowView(vault: book)
            }
        }
        .listStyle(GroupedListStyle())
    }
}

private struct RowView: View {
    let book: Book

    var body: some View {
        VStack(alignment: .leading) {
            Text(book.name)
                .foregroundColor(.white)
                .font(.headline)
            Text(book.text)
                .foregroundColor(.white)
                .font(.subheadline)
        }
        .padding()
        .frame(minWidth: 0, maxWidth: .infinity, alignment: .leading)
        .background(Color(hex: book.color))
        .cornerRadius(8)
    }
}

struct MainScreen: View {
    init() {
        UITabBar.appearance().backgroundColor = R.color.barBackground
        UITableView.appearance().backgroundColor = .clear
        UITableViewCell.appearance().backgroundColor = .clear
        UITableView.appearance().tableFooterView = UIView()
    }

    var body: some View {
        ZStack {
            R.color.background
                .edgesIgnoringSafeArea(.all)

            TabView {
                PersonalScreen()
                    .tabItem({
                        Image(sfSymbol: .bagFill)
                        Text("Personal")
                            .styleTabBarItem()
                    })
                CloudScreen()
                    .tabItem({
                        Image(sfSymbol: .cloudFill)
                        Text("Cloud")
                            .styleTabBarItem()
                    })
                SettingsScreen()
                    .tabItem({
                        Image(sfSymbol: .gear)
                        Text("Settings")
                            .styleTabBarItem()
                    })
            }
            .edgesIgnoringSafeArea(.top)
        }
    }
}

func getBooks() -> AnyPublisher<[Book], Error> {
    return Just([
        Book(id: "1", name: "Book 1"),
        Book(id: "2", name: "Book 2"),
    ])
    .eraseToAnyPublisher()
}

enum AppError: Error {
    case impossible
}

func getBooks() -> AnyPublisher<[Book], Error> {
    return Just([
        Book(id: "1", name: "Book 1"),
        Book(id: "2", name: "Book 2"),
    ])
    .mapError({ _ in  AppError.impossible })
    .eraseToAnyPublisher()
}

VStack {
    Text(data.title)
    Text(data.description!)
    Text(data.text!)
}

#if canImport(AppKit) && !targetEnvironment(macCatalyst)

@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)

import Combine
import Foundation

public protocol Reducer {
    associatedtype State
    associatedtype Mutation
    func reduce(state: State, mutation: Mutation) -> State
}

public struct AnyReducer<State, Mutation> {
    public let reduce: (State, Mutation) -> State
    public init<R: Reducer>(reducer: R) where R.State == State, R.Mutation == Mutation {
        self.reduce = reducer.reduce
    }
}

public protocol Action {
    associatedtype Mutation
    func toMutation() -> AnyPublisher<Mutation, Never>
}

public final class Store<State, Mutation>: ObservableObject {
    @Published public private(set) var state: State
    public let reducer: AnyReducer<State, Mutation>
    public private(set) var cancellables = Set<AnyCancellable>()

    public init(initialState: State, reducer: AnyReducer<State, Mutation>) {
        self.state = initialState
        self.reducer = reducer
    }

    public func send<A: Action>(action: A) where A.Mutation == Mutation {
        action
            .toMutation()
            .receive(on: DispatchQueue.main)
            .sink(receiveValue: update(mutation:))
            .store(in: &cancellables)
    }

    public func update(mutation: Mutation) {
        self.state = reducer.reduce(state, mutation)
    }
}

import SwiftUI
import Combine

typealias AppStore = Store<AppState, AppMutation>

let appStore: AppStore = AppStore(
    initialState: AppState(),
    reducer: appReducer
)

struct AppState: Codable {
    var hasShownOnboaring = false
}

struct AppReducer: Reducer {
    func reduce(state: AppState, mutation: AppMutation) -> AppState {
        var state = state
        switch mutation {
        case .finishOnboarding:
            state.hasShownOnboaring = true
        @unknown default:
            break
        }

        return state
    }
}

enum AppMutation {
    case finishOnboarding
}

struct RootScreen: View {
    @EnvironmentObject var store: AppStore
    
    var body: some View {
        if store.state.hasShownOnboaring {
            return Text("Welcome")
                .eraseToAnyView()
        } else {
            return OnboardingScreen()
                .eraseToAnyView()
        }
    }
}

struct OnboardingScreen: View {
    @EnvironmentObject var store: AppStore

    private func done() {
        store.send(action: AppAction.finishOnboarding)
    }
}

import Firebase
import FirebaseRemoteConfig

final class RemoteConfigHandler {
    let remoteConfig: RemoteConfig

    enum Key: String, CaseIterable {
        case interval = "fetch_interval"

        var defaultValue: NSNumber {
            switch self {
            case .periodicGetSalons: return NSNumber(value: 300)
            }
        }
    }

    init() {
        self.remoteConfig = RemoteConfig.remoteConfig()

        let settings = RemoteConfigSettings()
        settings.minimumFetchInterval = 0
        self.remoteConfig.configSettings = settings

        let map = Key.allCases.reduce([String: NSObject](), { map, key in
            var map = map
            map[key.rawValue] = key.defaultValue
            return map
        })

        self.remoteConfig.setDefaults(map)
    }

    func update()  {
        self.remoteConfig.fetchAndActivate(completionHandler: { status, error in
            print(status, error as Any)
        })
    }

    var fetchInterval: TimeInterval {
        return getValue(key: .interval, transform: { $0.doubleValue })
    }

    private func getValue<T>(key: Key, transform: (NSNumber) -> T) -> T {
        let number = remoteConfig.configValue(forKey: key.rawValue).numberValue ?? key.defaultValue
        return transform(number)
    }
}

@State private var image: UIImage

image // UIImage
_image // State<UIImage>
$image // Binding<UIImage>

class ViewModel: ObservableObject {
    var objectWillChange = ObservableObjectPublisher()

    var image: UIImage? {
        didSet {
            objectWillChange.send()
        }
    }
}

@ObservedObject var viewModel: ViewModel = ViewModel()

viewModel // ViewModel
_viewModel // ObservedObject<ViewModel>
$viewModel // ObservedObject<ViewModel>.Wrapper

@propertyWrapper public struct ObservedObject<ObjectType> : DynamicProperty where ObjectType : ObservableObject {

    /// A wrapper of the underlying `ObservableObject` that can create
    /// `Binding`s to its properties using dynamic member lookup.
    @dynamicMemberLookup public struct Wrapper {

        /// Creates a `Binding` to a value semantic property of a
        /// reference type.
        ///
        /// If `Value` is not value semantic, the updating behavior for
        /// any views that make use of the resulting `Binding` is
        /// unspecified.
        public subscript<Subject>(dynamicMember keyPath: ReferenceWritableKeyPath<ObjectType, Subject>) -> Binding<Subject> { get }
    }

    public init(initialValue: ObjectType)

    public init(wrappedValue: ObjectType)

    public var wrappedValue: ObjectType

    public var projectedValue: ObservedObject<ObjectType>.Wrapper { get }
}

struct ViewModel {
    var image: UIImage?
}

struct MainView: View {
    @State private var viewModel: ViewModel = ViewModel()
}

/// A value and a means to mutate it.
@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
@propertyWrapper @dynamicMemberLookup public struct Binding<Value> {
    /// Creates a new `Binding` focused on `Subject` using a key path.
    public subscript<Subject>(dynamicMember keyPath: WritableKeyPath<Value, Subject>) -> Binding<Subject> { get }
}

viewModel.image // UIImage?
$viewModel.image // Binding<UIImage?>
$viewModel.$image // Value of type 'ViewModel' has no member '$image'

import SwiftUI
import Combine

class ViewModel: ObservableObject {
    var objectWillChange = ObservableObjectPublisher()
    let imagePublisher = PassthroughSubject<UIImage, Never>()

    var image: UIImage? {
        willSet {
            objectWillChange.send()
            if let image = image {
                imagePublisher.send(image)
            }
        }
    }

    var isDetecting: Bool = false {
        willSet {
            objectWillChange.send()
        }
    }

    var result: String? {
        willSet {
            objectWillChange.send()
        }
    }
}

struct MainView: View {
    @State private var showImagePicker: Bool = false
    @ObservedObject var viewModel: ViewModel = ViewModel()

    private let detector = Detector()

    var body: some View {
        VStack {
            makeImage()
                .styleFit()

            if viewModel.isDetecting {
                ActivityIndicator(
                    isAnimating: $viewModel.isDetecting,
                    style: .large
                )
            }

            makeResult()

            Button(action: {
                self.showImagePicker.toggle()
            }, label: {
                Text("Choose image")
            })
            .sheet(isPresented: $showImagePicker, content: {
                ImagePicker(image: self.$viewModel.image, isPresented: self.$showImagePicker)
            })
        }
        .onReceive(viewModel.imagePublisher, perform: { image in
            self.detect(image: image)
        })
    }

    private func makeImage() -> Image {
        if let image = self.viewModel.image {
            return Image(uiImage: image)
        } else {
            return Image("placeholder")
        }
    }

    private func makeResult() -> Text {
        if let result = viewModel.result {
            return Text(result)
        } else {
            return Text("")
        }
    }

    private func detect(image: UIImage) {
        viewModel.isDetecting = true
        try? detector.detect(image: image, completion: { result in
            switch result {
            case .success(let string):
                self.viewModel.result = string
            default:
                self.viewModel.result = ""
            }

            self.viewModel.isDetecting = false
        })
    }
}

class Contact: ObservableObject {
    @Published var name: String
    @Published var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    func haveBirthday() -> Int {
        age += 1
        return age
    }
}

let john = Contact(name: "John Appleseed", age: 24)
john.objectWillChange.sink { _ in print("\(john.age) will change") }
print(john.haveBirthday())
// Prints "24 will change"
// Prints "25"

class ViewModel: ObservableObject {
    var objectWillChange = ObservableObjectPublisher()

    @Published var image: UIImage?
    @Published var isDetecting: Bool = false
    @Published var result: String?
}

.onReceive(viewModel.$image, perform: { image in
    if let image = image {
        self.detect(image: image)
    }
})

private func detect(image: UIImage) {
    viewModel.isDetecting = true
    try? detector.detect(image: image, completion: { result in
        switch result {
        case .success(let string):
            self.viewModel.result = string
        default:
            self.viewModel.result = ""
        }

        self.viewModel.isDetecting = false
        self.viewModel.objectWillChange.send()
    })
}

struct MainView: View {
    @State private var showImagePicker: Bool = false
    @State private var viewModel: ViewModel = ViewModel()
}

struct ViewModel {
    var imagePublisher = PassthroughSubject<UIImage?, Never>()
    var image: UIImage? {
        didSet {
            imagePublisher.send(image)
        }
    }
    var isDetecting: Bool = false
    var result: String?
}

struct MainView: View {
    @State private var showImagePicker: Bool = false
    @State private var viewModel: ViewModel = ViewModel()

    private let detector = Detector()

    var body: some View {
        VStack {
            makeImage()
                .styleFit()

            if viewModel.isDetecting {
                ActivityIndicator(
                    isAnimating: $viewModel.isDetecting,
                    style: .large
                )
            }

            makeResult()

            Button(action: {
                self.showImagePicker.toggle()
            }, label: {
                Text("Choose image")
            })
            .sheet(isPresented: $showImagePicker, content: {
                ImagePicker(image: self.$viewModel.image, isPresented: self.$showImagePicker)
            })
        }
        .onReceive(viewModel.imagePublisher, perform: { image in
            if let image = image {
                self.detect(image: image)
            }
        })
    }
}

@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
@propertyWrapper public struct State<Value> : DynamicProperty {

    /// Initialize with the provided initial value.
    public init(wrappedValue value: Value)

    /// Initialize with the provided initial value.
    public init(initialValue value: Value)

    /// The current state value.
    public var wrappedValue: Value { get nonmutating set }

    /// Produces the binding referencing this state value
    public var projectedValue: Binding<Value> { get }
}

/// A value and a means to mutate it.
@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
@propertyWrapper @dynamicMemberLookup public struct Binding<Value> {

    /// The transaction used for any changes to the binding's value.
    public var transaction: Transaction

    /// Initializes from functions to read and write the value.
    public init(get: @escaping () -> Value, set: @escaping (Value) -> Void)

    /// Initializes from functions to read and write the value.
    public init(get: @escaping () -> Value, set: @escaping (Value, Transaction) -> Void)

    /// Creates a binding with an immutable `value`.
    public static func constant(_ value: Value) -> Binding<Value>

    /// The value referenced by the binding. Assignments to the value
    /// will be immediately visible on reading (assuming the binding
    /// represents a mutable location), but the view changes they cause
    /// may be processed asynchronously to the assignment.
    public var wrappedValue: Value { get nonmutating set }

    /// The binding value, as "unwrapped" by accessing `$foo` on a `@Binding` property.
    public var projectedValue: Binding<Value> { get }

    /// Creates a new `Binding` focused on `Subject` using a key path.
    public subscript<Subject>(dynamicMember keyPath: WritableKeyPath<Value, Subject>) -> Binding<Subject> { get }
}

import SwiftUI

struct ActivityIndicator: UIViewRepresentable {
    @Binding var isAnimating: Bool
    let style: UIActivityIndicatorView.Style

    func makeUIView(context: UIViewRepresentableContext<ActivityIndicator>) -> UIActivityIndicatorView {
        return UIActivityIndicatorView(style: style)
    }

    func updateUIView(_ uiView: UIActivityIndicatorView, context: UIViewRepresentableContext<ActivityIndicator>) {
        isAnimating ? uiView.startAnimating() : uiView.stopAnimating()
    }
}

struct ActivityIndicator_Previews: PreviewProvider {
    static var previews: some View {
        ActivityIndicator(isAnimating: .constant(true), style: .large)
    }
}

import SwiftUI
import UIKit

public struct ImagePicker: UIViewControllerRepresentable {
    @Environment(\.presentationMode) private var presentationMode
    @Binding var image: UIImage?

    public func makeCoordinator() -> ImagePicker.Coordinator {
        return ImagePicker.Coordinator(
            presentationMode: presentationMode,
            image: $image
        )
    }

    public func makeUIViewController(context: UIViewControllerRepresentableContext<ImagePicker>) -> UIImagePickerController {
        let controller = UIImagePickerController()
        controller.delegate = context.coordinator
        return controller
    }

    public func updateUIViewController(_ uiViewController: UIImagePickerController, context: UIViewControllerRepresentableContext<ImagePicker>) {
        // No op
    }
}

public extension ImagePicker {
    class Coordinator: NSObject, UINavigationControllerDelegate {
        @Binding var presentationMode: PresentationMode
        @Binding var image: UIImage?

        public init(presentationMode: Binding<PresentationMode>, image: Binding<UIImage?>) {
            self._presentationMode = presentationMode
            self._image = image
        }
    }
}

extension ImagePicker.Coordinator: UIImagePickerControllerDelegate {
    public func imagePickerController(
        _ picker: UIImagePickerController,
        didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
        self.image = info[UIImagePickerController.InfoKey.originalImage] as? UIImage
        presentationMode.dismiss()
    }

    public func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
        presentationMode.dismiss()
    }
}

@Environment(\.presentationMode) private var presentationMode

public func makeCoordinator() -> ImagePicker.Coordinator {
    return ImagePicker.Coordinator(
        image: $image,
        isPresented: $isPresented
    )
}

class Coordinator: NSObject, UINavigationControllerDelegate {
    @Binding var presentationMode: PresentationMode
    @Binding var image: UIImage?

    public init(presentationMode: Binding<PresentationMode>, image: Binding<UIImage?>) {
        self._presentationMode = presentationMode
        self._image = image
    }
}

Button(action: {
    self.showImagePicker.toggle()
}, label: {
    Text("Choose image")
})
.sheet(isPresented: $showImagePicker, content: {
    ImagePicker(image: self.$image)
})

public func makeCoordinator() -> ImagePicker.Coordinator {
    return ImagePicker.Coordinator(
        presentationMode: presentationMode,
        image: $image
    )
}

Button(action: {
    self.showImagePicker.toggle()
}, label: {
    Text("Choose image")
})
.sheet(isPresented: $showImagePicker, content: {
    ImagePicker(image: self.$image, onDone: {
        self.presentationMode.wrappedValue.dismiss()
    })
})

import SwiftUI
import UIKit

public struct ImagePicker: UIViewControllerRepresentable {
    @Binding var image: UIImage?
    @Binding var isPresented: Bool

    public func makeCoordinator() -> ImagePicker.Coordinator {
        return ImagePicker.Coordinator(
            image: $image,
            isPresented: $isPresented
        )
    }

    public func makeUIViewController(context: UIViewControllerRepresentableContext<ImagePicker>) -> UIImagePickerController {
        let controller = UIImagePickerController()
        controller.delegate = context.coordinator
        return controller
    }

    public func updateUIViewController(_ uiViewController: UIImagePickerController, context: UIViewControllerRepresentableContext<ImagePicker>) {
        // No op
    }
}

public extension ImagePicker {
    class Coordinator: NSObject, UINavigationControllerDelegate {
        @Binding var isPresented: Bool
        @Binding var image: UIImage?

        public init(image: Binding<UIImage?>, isPresented: Binding<Bool>) {
            self._image = image
            self._isPresented = isPresented
        }
    }
}

extension ImagePicker.Coordinator: UIImagePickerControllerDelegate {
    public func imagePickerController(
        _ picker: UIImagePickerController,
        didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
        self.image = info[UIImagePickerController.InfoKey.originalImage] as? UIImage
        isPresented = false
    }

    public func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
        isPresented = false
    }
}

Button(action: {
    self.showImagePicker.toggle()
}, label: {
    Text("Choose image")
})
.sheet(isPresented: $showImagePicker, content: {
    ImagePicker(image: self.$image, isPresented: self.$showImagePicker)
})

import XCTest
import SwiftMonkey

class MonkeyTests: XCTestCase {
    var app: XCUIApplication!

    override func setUp() {
        continueAfterFailure = false
        app = XCUIApplication()
        app.launch()
    }

    func testMonkey() {
        let monkey = Monkey(frame: app.frame)
        monkey.addDefaultUIAutomationActions()
        monkey.addXCTestTapAlertAction(interval: 100, application: app)
        monkey.monkeyAround()
    }
}

monkey.addXCTestTapAlertAction(interval: 100, application: app)