import Foundation
import Combine

public typealias TaskCompletion = (Result<(), Error>) -> Void

public protocol Task: AnyObject {
    var name: String { get }
    func run(workflow: Workflow, completion: TaskCompletion)
}

public extension Task {
    func asPublisher(workflow: Workflow) -> AnyPublisher<(), Error> {
        return Future({ completion in
            self.run(workflow: workflow, completion: completion)
        }).eraseToAnyPublisher()
    }
}

let sequence = Publishers.Sequence<[AnyPublisher<(), Error>], Error>(
    sequence: tasks.map({ $0.asPublisher(workflow: self) })
)

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

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

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()
}

struct FlatMap<NewPublisher, Upstream> where NewPublisher : Publisher, Upstream : Publisher, NewPublisher.Failure == Upstream.Failure

struct Sequence<Elements, Failure> where Elements : Sequence, Failure : Error

func fetchItems(completion: @escaping ([ItemProtocol]) -> Void) {
    requestCancellable = URLSession.shared
        .dataTaskPublisher(for: topStoriesUrl())
        .map({ $0.data })
        .decode(type: [Int].self, decoder: JSONDecoder())
        .flatMap({ (ids: [Int]) -> AnyPublisher<[HackerNews.Item], Error> in
            let publishers = ids.prefix(10).map({ id in
                return URLSession.shared
                    .dataTaskPublisher(for: self.storyUrl(id: id))
                    .map({ $0.data })
                    .decode(type: HackerNews.Item.self, decoder: JSONDecoder())
                    .eraseToAnyPublisher()
            })

            return Publishers.Sequence<[AnyPublisher<HackerNews.Item, Error>], Error>(sequence: publishers)
                // Publishers.Sequence<[AnyPublisher<HackerNews.Item, Error>], Error>
                .flatMap({ $0 })
                // Publishers.FlatMap<AnyPublisher<HackerNews.Item, Error>, Publishers.Sequence<[AnyPublisher<HackerNews.Item, Error>], Error>>
                .collect()
                // Publishers.Collect<Publishers.FlatMap<AnyPublisher<HackerNews.Item, Error>, Publishers.Sequence<[AnyPublisher<HackerNews.Item, Error>], Error>>>
                .eraseToAnyPublisher()
                // AnyPublisher<[HackerNews.Item], Error>
        })
        .receive(on: RunLoop.main)
        .eraseToAnyPublisher()
        .sink(receiveCompletion: { completionStatus in
            switch completionStatus {
            case .finished:
                break
            case .failure(let error):
                print(error)
            }
        }, receiveValue: { items in
            completion(items)
        })
}