//
//  OrderRepository.swift
//  PaiAi
//
//  Created by zhengjianfei on 16/4/7.
//  Copyright © 2016年 FFIB. All rights reserved.
//

import Foundation
import RxSwift
import RxCocoa

public protocol OrderRepositorable: Repositorable where Content == [OrderItem] {}

final public class OrderRepository: Resource {
    fileprivate var items: BehaviorRelay<[OrderItem]>
    fileprivate var hasMore: Bool
    fileprivate var page: Int
    fileprivate var loadingSchedule: PublishSubject<Bool>
    
    var path: Interfaces { return .orderList }
    #warning("user_id 填充")
    var parameter: Parameter = ["user_id": ""]
    
    init() {
        page = 1
        hasMore = true
        loadingSchedule = PublishSubject<Bool>()
        items = BehaviorRelay<[OrderItem]>(value: [])
    }
}

extension OrderRepository: Parsable {
    typealias Model = [OrderItem]
    
    func parse(_ json: JSON) -> [OrderItem]? {
        guard let data = json["data"],
            let orders = data["orders"] as? [[String: AnyObject]],
            let left = data["left"] as? Int else { return nil }
        hasMore = left > 0
        return orders.map { return OrderItem(json: $0) }
    }
}

extension OrderRepository: Gettable {
    public func loadContent(isRefresh: Bool) {
        guard hasMore else {
            loadingSchedule.onNext(isRefresh)
            return
        }
        
        page = isRefresh ? 1 : page + 1
        parameter["page"] = page
        let _ = NetworkApi.share.post(resource: self) { result in
            
            defer { self.loadingSchedule.onNext(isRefresh) }
            
            guard case let .success(items) = result else {
                return
            }
            
            if isRefresh {
                self.items.accept(items)
            } else {
                self.items.accept(self.items.value + items)
            }
        }
    }
}

extension OrderRepository: OrderRepositorable {
    public var content: Observable<[OrderItem]> {
        return items.asObservable()
            .flatMap { currentItems in
                Observable.just(currentItems)
                    .distinctUntilChanged()
            }.share()
    }
    
    public var loadingObserver: Observable<Bool> {
        return loadingSchedule.asObserver()
            .flatMap { current in
                Observable.just(current)
            }.share()
    }
}