import Foundation
import Teller
import RxSwift
import Moya

class ReposRequirements: RepositoryRequirements {
    
    /**
     The tag is used to determine how old your cache is. Teller uses this to determine if a fresh cache needs to be fetched or not. If the tag matches previously cached data of the same tag, the data that data was fetched will be queried and determined if it's considered too old and will fetch fresh data or not from the result of the compare.
     
     The best practice is to describe what the cache represents. "Repos for <username>" is a great example. 
     */
    var tag: ReposRepositoryRequirements.Tag {
        return "Repos for \(username)"
    }
    
    let username: String
    
    init(username: String) {
        self.username = username
    }
}

// Struct used to represent the JSON data pulled from the GitHub API.
struct Repo: Codable {
    var id: Int!
    var name: String!
}

class ReposRepositoryDataSource: RepositoryDataSource {
    
    typealias Cache = [Repo]
    typealias Requirements = ReposRepositoryRequirements
    typealias FetchResult = [Repo]
    typealias FetchError = Error
    
    // How old a cache can be before it's considered old and an automatic refresh should be performed. 
    // Teller tries to reduce the number of network calls performed to save on bandwidth of your user's device. 
    var maxAgeOfCache: Period = Period(unit: 5, component: .hour)
    
    func fetchFreshCache(requirements: Requirements) -> Single<FetchResponse<Cache, FetchError>> {
        // Return network call that returns a RxSwift Single.
        // The project Moya (https://github.com/moya/moya) is my favorite library to do this.
                
        return MoyaProvider<GitHubService>().rx.request(.listRepos(user: requirements.username))
            .map({ (response) -> FetchResponse<[Repo]> in
                let repos = try! JSONDecoder().decode([Repo].self, from: response.data)
                
                // If there was a failure, use FetchResponse.failure(Error) and the error will be sent to your user in the UI
                return FetchResponse.success(data: repos)
            })
    }
    
    // Note: Teller runs this function from a background thread.
    func saveCache(_ fetchedData: Cache, requirements: Requirements) throws {
        // Save data to CoreData, Realm, UserDefaults, File, whatever you wish here.
        // If there is an error, you may throw it, and have it get passed to the observer of the Repository.
    }
    
    // Note: Teller runs this function from the UI thread
    func observeCache(requirements: Requirements) -> Observable<Cache> {
        // Return Observable that is observing the cached data.
        //
        // When any of the repos in the database have been changed, we want to trigger an Observable update.
        // Teller may call `observeCachedData` regularly to keep data fresh.
        
        return Observable.just([])
    }

    // Note: Teller runs this function from the same thread as `observeCachedData()`
    func isCacheEmpty(_ cache: Cache, requirements: Requirements) -> Bool {
        return cache.isEmpty
    }
    
}

let disposeBag = DisposeBag()
let repository = TellerRepository(dataSource: ReposRepositoryDataSource())

repository.requirements = ReposRepositoryDataSource.Requirements(username: "username to get repos for")
repository
    .observe()
    .observeOn(ConcurrentDispatchQueueScheduler(qos: .background))
    .subscribeOn(MainScheduler.instance)
    .subscribe(onNext: { (cacheState: CacheState<[Repo]>) in
        // Teller provides a handy way to parse the `CacheState` to understand the state your cache is in. 
        switch cacheState.state {
        // No cache exists. A successful network request has not happened yet. 
        case .noCache:
            // Repos have never been fetched before for the GitHub user.
            break
        case .cache(let cache, let cacheAge):            
            // Repos have been fetched before for the GitHub user.            
            let isCacheEmpty = cache == nil // If `cache` is nil, the cache is empty.
            // Use `cacheAge` in your UI to tell the user how long ago the last successful network request was. 
        }

        // You can inspect a lot more about the state of your cache. 
        cacheState.isRefreshing // If a network request is happening right now to refresh the cache
        cacheState.justFinishedFirstFetch // The first successful network call just finished
        cacheState.refreshError // Get error from network call if there was one during refresh
        // ... and more. Use these properties in the UI of your app to be transparent about your cache!
    })
    .disposed(by: disposeBag)

// `PagingRepositoryRequirements` is a special object used to understand how to fetch pages of data from a network. 
// Some APIs you work with might
// ...use a page number, like GitHub: https://developer.github.com/v3/guides/traversing-with-pagination/
// ...use an ID of your last retrieved item, like SoundCloud https://developers.soundcloud.com/docs/api/guide#pagination
// ...use an ID of the first and last retrieved item, like Twitter  https://developer.twitter.com/en/docs/ads/general/guides/pagination
// 
// Whatever your API uses, you put those properties in this object to keep track of what page you are viewing now. 
struct ReposPagingRequirements: PagingRepositoryRequirements {
    let pageNumber: Int

    func nextPage() -> ReposPagingRequirements {
        return ReposPagingRequirements(pageNumber: pageNumber + 1)
    }
}

class ReposRepositoryDataSource: PagingRepositoryDataSource {
    // The data type your cache is. What `observe()` will use. 
    typealias PagingCache = [Repo]
    // `RepositoryRequirements` subclass you're using
    typealias Requirements = ReposRepositoryRequirements
    // `PagingRepositoryRequirements` subclass you're using
    typealias PagingRequirements = ReposPagingRequirements
    // If you're using an API like Twitter or SoundCloud where future network calls depend 
    // data discovered from the previous network call, this field takes care of that. 
    // Use an Int, String, Tuple, Struct, etc for this. 
    // The GitHub API will simply go to the next page number so this field is not used.     
    typealias NextPageRequirements = Void
    // The data type returned from network calls. 
    typealias PagingFetchResult = [Repo]
    // Use a custom Error for network calls in your fetch calls. 
    typealias FetchError = Error

    static let reposPageSize = 50

    // You can use whatever method you wish for performing a HTTP network call. Moya is used in this example. 
    let moyaProvider = MoyaProvider<GitHubService>(plugins: [HttpLoggerMoyaPlugin()])
    let keyValueStorage = UserDefaultsKeyValueStorage(userDefaults: UserDefaults.standard)

    var maxAgeOfCache: Period = Period(unit: 5, component: .hour)

    var currentRepos: [Repo] {
        guard let currentReposData = keyValueStorage.string(forKey: .repos)?.data else {
            return []
        }

        return try! JSONDecoder().decode([Repo].self, from: currentReposData)
    }

    // When you call `goToNextPage()` on your `TellerPagingRepository`, this function is called to get a new `PagingRequirements` for the next network call. 
    func getNextPagePagingRequirements(currentPagingRequirements: PagingRequirements, nextPageRequirements: NextPageRequirements?) -> PagingRequirements {
        return currentPagingRequirements.nextPage()
    }

    // Teller will call this automatically when it needs. You need to delete all of your cache for the given `Requirements`. 
    // Note: Teller runs this function from a background thread.
    func deleteCache(_ requirements: Requirements) {
        keyValueStorage.delete(key: .repos)
    }

    // Teller will call this automatically when it needs. You need to delete all of your cache for the given `Requirements` *except* for the first page of cache.
    // Note: Teller runs this function from a background thread.
    func persistOnlyFirstPage(requirements: ReposRepositoryRequirements) {
        let currentRepos = self.currentRepos
        guard currentRepos.count > ReposRepositoryDataSource.reposPageSize else {
            return
        }

        let firstPageRepos = Array(currentRepos[0...ReposRepositoryDataSource.reposPageSize])

        keyValueStorage.setString((try! JSONEncoder().encode(firstPageRepos)).string!, forKey: .repos)
    }

    // The network call function has changed in the return type that you return. 
    func fetchFreshCache(requirements: ReposRepositoryRequirements, pagingRequirements: PagingRequirements) -> Single<FetchResponse<FetchResult, Error>> {
        // Return network call that returns a RxSwift Single.
        // The project Moya (https://github.com/moya/moya) is my favorite library to do this.
        return moyaProvider.rx.request(.listRepos(user: requirements.username, pageNumber: pagingRequirements.pageNumber))
            .map { (response) -> FetchResponse<FetchResult, FetchError> in
                let repos = try! JSONDecoder().decode([Repo].self, from: response.data)

                let responseHeaders = response.response!.allHeaderFields
                let paginationNext = responseHeaders["link"] as? String ?? responseHeaders["Link"] as! String
                let areMorePagesAvailable = paginationNext.contains("rel=\"next\"")

                // When using pagination, Teller requires your fetch function to return more information regarding the network calls. 
                // You need to determine if there are more pages to fetch, or not. 
                // Also, populate `nextPageRequirements` with whatever you want that will get passed to `getNextPagePagingRequirements` when you call `goToNextPage()`. 
                // 
                // If there was a failure, use FetchResponse.failure(Error) and the error will be sent to your user in the UI
                return FetchResponse.success(PagedFetchResponse(areMorePages: areMorePagesAvailable, nextPageRequirements: nil, fetchResponse: repos))
            }
    }

    // Save the cache. Friendly reminder to *append* the new cache to storage. You don't want to replace the cache you already have as pagination builds on top of each other. 
    // Note: Teller runs this function from a background thread.    
    func saveCache(_ cache: [Repo], requirements: ReposRepositoryRequirements, pagingRequirements: PagingRequirements) throws {
        // Save data to CoreData, Realm, UserDefaults, File, whatever you wish here.
        // If there is an error, you may throw it, and have it get passed to the observer of the Repository.
        var combinedRepos = currentRepos
        combinedRepos.append(contentsOf: cache)

        keyValueStorage.setString((try! JSONEncoder().encode(combinedRepos)).string!, forKey: .repos)
    }

    // This function has not changed from the getting started guide.     
    // Note: Teller runs this function from the UI thread
    func observeCache(requirements: ReposRepositoryRequirements, pagingRequirements: ReposPagingRequirements) -> Observable<PagingCache> {
        // Return Observable that is observing the cached data.
        //
        // When any of the repos in the database have been changed, we want to trigger an Observable update.
        // Teller may call `observeCachedData` regularly to keep data fresh.

        return keyValueStorage.observeString(forKey: .repos)
            .map { (string) -> PagingCache in
                try! JSONDecoder().decode([Repo].self, from: string.data!)
            }
    }

    // This function has not changed from the getting started guide.   
    // Note: Teller runs this function from the same thread as `observeCachedData()`
    func isCacheEmpty(_ cache: [Repo], requirements: ReposRepositoryRequirements, pagingRequirements: ReposPagingRequirements) -> Bool {
        return cache.isEmpty
    }
}

let disposeBag = DisposeBag()
let repository = TellerPagingRepository(dataSource: ReposRepositoryDataSource(), firstPageRequirements: ReposRepositoryDataSource.PagingRequirements(pageNumber: 1))

let reposGetDataRequirements = ReposRepositoryDataSource.Requirements(username: "username to get repos for")
repository.requirements = reposGetDataRequirements
repository
    .observe()
    .observeOn(ConcurrentDispatchQueueScheduler(qos: .background))
    .subscribeOn(MainScheduler.instance)
    .subscribe(onNext: { (dataState: CacheState<PagedCache<[Repo]>>) in
        switch dataState.state {
        case .noCache:
            // Repos have never been fetched before for the GitHub user.
            break
        case .cache(let cache, let cacheAge):
            // Repos have been fetched before for the GitHub user.
            // If `cache` is nil, the cache is empty.
            if let pagedCache = cache {
                let repositories = pagedCache.cache
                let areMorePages = pagedCache.areMorePages

                // Show/hide a "Loading more" footer in your UITableView by `areMorePages` value.
            } else {
                // The cache is empty! There are no repos for that particular username.
                // Display a view in your app that tells the user there are no repositories to show.
            }

            // Access all of the properties you're used to when not using pagination:
            cacheState.isRefreshing
        }
    })
    .disposed(by: disposeBag)

// When the `UITableView` is scrolled down to the bottom, do...
repository.goToNextPage()
// ...and the next page of cache will be fetched!

let repository = TellerRepository(dataSource: ReposRepositoryDataSource())
repository.requirements = ReposRepositoryDataSource.Requirements(username: "username to get repos for")

try! repository.refresh(force: false)
        .subscribe()

let repository = TellerRepository(dataSource: ReposRepositoryDataSource())
repository.requirements = ReposRepositoryDataSource.Requirements(username: "username to get repos for")

try! repository.refreshIfNoCache()
    .subscribe(onSuccess: { (refreshResult) in
        if case .successful = refreshResult {
            // Cache does exist.
        } else {
            // Cache does not exist. View the error in `refreshResult` to see why the refresh attempt failed.
        }
    })

let repository = TellerRepository(dataSource: ReposRepositoryDataSource())
repository.requirements = ReposRepositoryDataSource.Requirements(username: "username to get repos for")

repository.refresh(force: true)
        .subscribe()

repository.observe()
.map { (dataState) -> CacheState<B> in
    dataState.convert { (a) -> B? in
        guard let a = a else { return nil }
        B(a: a)
    }
}

class ReposRepositoryDataSource: RepositoryDataSource {
    // override default value.
    var automaticallyRefresh: Bool {
        return false
    }
}

import RxBlocking
import RxSwift
@testable import YourApp
import XCTest

class RepositoryViewModelTest: XCTestCase {
    var viewModel: ReposViewModel!
    var repository: RepositoryMock<ReposRepositoryDataSource>!

    override func setUp() {
        // Create an instance of `RepositoryMock`
        repository = TellerRepositoryMock(dataSource: ReposRepositoryDataSource())
        // Provide the repository mock to your code under test with dependency injection
        viewModel = ReposViewModel(reposRepository: repository)
    }
    
    func test_observeRepos_givenReposRepositoryObserve_expectReceiveCacheFromReposRepository() {
        // 1. Setup the mock
        let given: CacheState<[Repo]> = DataState.testing.cache(requirements: ReposRepositoryDataSource.Requirements(username: "username"), lastTimeFetched: Date()) {
            $0.cache([
                Repo(id: 1, name: "repo-name")
            ])
        }
        repository.observeClosure = {
            return Observable.just(given)
        }
        
        // 2. Run the code under test
        let actual = try! repository.observe().toBlocking().first()
        
        // 3. Assert your code under test is working
        XCTAssertEqual(given, actual)
    }
    
    func test_setReposToObserve_givenUsername_expectSetRepositoryRequirements() {
        let given = "random-username"
        
        // Run your code under test
        viewModel.setReposToObserve(username: given)

        // Pull out the properties of the repository mock to see if your code under test works as expected
        XCTAssertTrue(repository.requirementsCalled)
        XCTAssertEqual(repository.requirementsCallsCount, 1)
        let actual = repository.requirementsInvocations[0]!.username
        XCTAssertEqual(given, actual)
    }

}

import XCTest
import Teller 

class YourIntegrationTests: XCTestCase {    

    override func setUp() {        
        Teller.shared.clear()
    }
}

import XCTest
import Teller 

class YourIntegrationTests: XCTestCase {    
    private var dataSource: RepositoryDataSource<String, RepositoryRequirements, String>!
    private var repository: TellerRepository<RepositoryDataSource<String, RepositoryRequirements, String>>!

    override func setUp() {
        dataSource = RepositoryDataSource()
        repository = TellerRepository(dataSource: dataSource)
        
        Teller.shared.clear()
    }

    func test_tellerNoCach() {                
        let requirements = RepositoryDataSource.Requirements(username: "")
        
        _ = TellerRepository.testing.initState(repository: repository, requirements: requirements) {
            $0.noCache()
        }     

        // Teller is all setup! When your app's code uses the `repository`, it will behave just like the `TellerRepository` has never fetched a cache successfully before. 

        // Write the remainder of your integration test function here. 
    }

    func test_tellerCacheEmpty() {                
        let requirements = RepositoryDataSource.Requirements(username: "")
        
        _ = TellerRepository.testing.initState(repository: repository, requirements: requirements) {
            $0.cacheEmpty() {
                $0.cacheTooOld()
            }            
        }     

        // Teller is all setup! When your app's code uses the `repository`, it will behave just like the `TellerRepository` has fetched a cache successfully, the cache is empty, and the cache is too old which means Teller will attempt to fetch a fresh cache the next time the `TellerRepository` runs.

        // There are other options for `$0.cacheEmpty()` such as:
        //  $0.cacheEmpty() {
        //    $0.cacheNotTooOld()
        //  }         
        // 
        // $0.cacheEmpty() {
        //    $0.lastFetched(Date.yesterday)
        //  }

        // Write the remainder of your integration test function here. 
    }    

    func test_tellerCacheNotEmpty() {
        let requirements = RepositoryDataSource.Requirements(username: "")
        let existingCache = "existing-cache"
        
        _ = TellerRepository.testing.initState(repository: repository, requirements: requirements) {
            $0.cache(existingCache) {
                $0.cacheNotTooOld()
            }
        }     
        // *Note: If your `DataSource.saveCache()` function needs to be executed on a background thread, use `TellerRepository.testing.initStateAsync()` instead of `initState()` shown here. `initSync()` runs the `DataSource.saveCache()` on the thread that you call `initState()` on.*

        // Teller is all setup! When your app's code uses the `repository`, it will behave just like the `TellerRepository` has fetched a cache successfully, the cache is not empty and contains "existing-cache", and the cache is not too old (the default behavior when a state is not given) which means Teller will not attempt to fetch a fresh cache the next time the `TellerRepository` runs.

        // There are other options for `$0.cache(existingCache)`. They are the same options as $0.cacheEmpty() described above.

        // Write the remainder of your integration test function here. 
    }
}