paiai_ios/PaiAi/PaiaiDataKit/DataLayer/Repositories/OrderModelRepository.swift

//
//  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 OrderModelRepository {
    fileprivate var items: BehaviorRelay<[OrderItem]>
    fileprivate var hasMore = true
    fileprivate var page = 1
    fileprivate var contentsResource: Resource<[OrderItem]>?
}

public protocol OrderRepository: Repositorable where Content == [PhotoItem] {}

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

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

extension HomePhotoRepository: 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(photoItems) = result else {
                return
            }
            
            if isRefresh {
                self.items.accept(photoItems)
            } else {
                self.items.accept(self.items.value + photoItems)
            }
        }
    }
}

extension HomePhotoRepository: HomePhotoRepositorable {
    public var content: Observable<[PhotoItem]> {
        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()
    }
}

extension HomePhotoRepository: Layoutable {
    public func layoutSizeForIndex(_ index: Int) -> CGSize {
        let h = items.value[index].photo_thumbnail_h
        let w = items.value[index].photo_thumbnail_w
        return CGSize(width: w, height: h)
    }
}


final class OrderModel {
    
    
    init() {
        items = BehaviorRelay<[OrderItem]>(value: [])
        contentsResource =  Resource(url: .orderList,
                                     param: ["user_id": SharedUserInfo.userId as AnyObject],
                                     parse: parse)
    }
    
    private func parse(json: [String: AnyObject]) -> [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) }
    }
    
    func loadContents(isRefresh: Bool) {
        guard hasMore else { return }
        page = isRefresh ? 1 : page + 1
        contentsResource?.parameter["page"] = page as AnyObject
        NetworkApi.share.post(resource: contentsResource!) { [weak self] result in
            guard case let .success(orderItems) = result else { return }
            guard let `self` = self else { return }
            if isRefresh {
                self.items.accept(orderItems)
            } else {
                self.items.accept(orderItems + self.items.value)
            }
        }
    }
}