//
//  GroupModel.swift
//  PaiAi
//
//  Created by FFIB on 16/4/1.
//  Copyright © 2016年 FFIB. All rights reserved.
//

import Foundation
import RxCocoa
import RxSwift

struct GroupDeleteResource: Resource {
    var path: Interfaces { return .groupDelete }
    #warning("user_id 填充")
    var parameter: Parameter = ["user_id": ""]
}

extension GroupDeleteResource: Parsable {
    typealias Model = StatusModel
    func parse(_ json: JSON) -> StatusModel? {
        return StatusModel(json: json)
    }
}

public protocol GroupRepositorable: Repositorable where Content == [GroupItem] {}

final public class GroupRepository: Resource {
    fileprivate var items: BehaviorRelay<[GroupItem]>
    fileprivate var hasMore: Bool
    fileprivate var page: Int
    fileprivate var loadingSchedule: PublishSubject<Bool>
    
    var path: Interfaces { return .groupList }
    #warning("admin_id 填充")
    var parameter: Parameter = ["admin_id": ""]
    fileprivate var deleteResource: GroupDeleteResource
    
    
    init() {
        page = 1
        hasMore = true
        loadingSchedule = PublishSubject<Bool>()
        items = BehaviorRelay<[GroupItem]>(value: [])
        deleteResource = GroupDeleteResource()
    }
}

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

extension GroupRepository: 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 GroupRepository: 

extension GroupRepository: GroupRepositorable {
    public var content: Observable<[GroupItem]> {
        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()
    }
}



final class GroupModel {
    private(set) var items: BehaviorRelay<[GroupItem]>
    private var hasMore = true
    private var page = 1
    private var contentsResource: Resource<[GroupItem]>?
    private var deleteItemResource: Resource<StatusModel>?
    
    
    init() {
        items = BehaviorRelay<[GroupItem]>(value: [])
        
        contentsResource =  Resource(url: .groupList,
                                     param: ["user_id": SharedUserInfo.userId as AnyObject],
                                     parse: parse)
        deleteItemResource = Resource(url: .groupDelete,
                                      param: ["admin_id": SharedUserInfo.userId as AnyObject],
                                      parse: parseStatus)
    }
    
    private func parse(json: [String: AnyObject]) -> [GroupItem]? {
        
    }
    
    private func parseStatus(json: [String: AnyObject]) -> StatusModel? {
        return StatusModel(json: json)
    }
    
    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(messageItems) = result else { return }
            guard let `self` = self else { return }
            if isRefresh {
                self.items.accept(messageItems)
            } else {
                self.items.accept(self.items.value + messageItems)
            }
            
        }
    }
    
    #warning("错误逻辑")
    func remove(_ item: GroupItem) {
        guard let index = items.value.index(where: { $0 == item }) else { return }
        deleteItemResource!.parameter["group_id"] = item.group_id as AnyObject
        NetworkApi.share.post(resource: deleteItemResource!) { [weak self] result in
            guard case let .success(statusModel) = result else { return }
            guard let `self` = self else { return }
            if statusModel.status == 200 {
                var values = self.items.value
                values.remove(at: index)
                self.items.accept(values)
            } else if statusModel.status == 402010 {
                
            } else if statusModel.status == 402099 {
                
            }
        }
    }
}