//
//  Connection.swift
//
//  Created by iTSangar on 10/3/15.
//  Copyright © 2015 iTSangar. All rights reserved.
//

import Foundation
import Alamofire
import ObjectMapper

enum Result<T> {
  case Success(T)
  case Error(String)
}

// MARK: - User Class
class APIUser {

  class func login(email email: String, password: String, completion: Result<User?> -> Void) {
    Alamofire.request(Router.UserLogin(["email": email, "password": password]))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            let user = Mapper<User>().map(JSON)
            completion(Result.Success(user!))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func changePassword(userID id: Int, email: String, newPassword: String, completion: Result<User?> -> Void) {
    Alamofire.request(Router.UserNewPassword(id: id, ["email": email, "newpassword": newPassword]))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            let user = Mapper<User>().map(JSON)
            completion(Result.Success(user!))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

}

// MARK: - Timeline Class
class APITimeline {

  class func user(completion: Result<Array<AnyObject>?> -> Void) {
    timeline("user", completion: completion)
  }

  class func guest(completion: Result<Array<AnyObject>?> -> Void) {
    timeline("guest", completion: completion)
  }

  private class func timeline(type: String, completion: Result<Array<AnyObject>?> -> Void) {
    Alamofire.request(Router.Timeline(["type": type]))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            completion(Result.Success(parse(JSON)))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  private class func parse(json: AnyObject) -> Array<AnyObject>? {
    var timeline = Array<AnyObject>()

    if let tt = Mapper<TimelineType>().map(json) {
      if let t = Mapper<Timeline>().map(json) {
        if let r = tt.types {
          for var index = 0; index < r.count; ++index {
            switch r[index].type! {
            case .Forum:
              timeline.append(Mapper<Forum>().map(t.rows![index])!)
              break
            case .Calendar:
              timeline.append(Mapper<Calendar>().map(t.rows![index])!)
              break
            case .Survey:
              timeline.append(Mapper<Survey>().map(t.rows![index])!)
              break
            case .News:
              timeline.append(Mapper<News>().map(t.rows![index])!)
              break
            case .Facebook:
              timeline.append(Mapper<Facebook>().map(t.rows![index])!)
              break
            case .Twitter:
              timeline.append(Mapper<Twitter>().map(t.rows![index])!)
              break
            }
          }
        }
      }
    }

    return timeline
  }

}

// MARK: - Forum Class
class APIForum {

  class func forums(completion: Result<Forums?> -> Void) {
    Alamofire.request(Router.Forum)
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            let forums = Mapper<Forums>().map(JSON)
            completion(Result.Success(forums!))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func new(userID id: Int, title:String, completion: Result<String?> -> Void) {
    Alamofire.request(Router.ForumNew(["user": id, "title": title]))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            completion(Result.Success(status!.message))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func replies(forumID id: Int, completion: Result<Replies?> -> Void) {
    APIReply.replies(type: Constant.FiegForum, id: id, completion: completion)
  }

  class func newReply(forumID id: Int, userID: Int, reply: String, completion: Result<String?> -> Void) {
    APIReply.newReply(type: Constant.FiegForum, id: id, user: userID, reply: reply, completion: completion)
  }

  class func deleteReply(replyID id: Int, completion: Result<String?> -> Void) {
    APIReply.delete(type: Constant.FiegForum, id: id, completion: completion)
  }

}

// MARK: - Survey Class
class APISurvey {

  class func surveys(completion: Result<Surveys?> -> Void) {
    Alamofire.request(Router.Surveys)
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            let surveys = Mapper<Surveys>().map(JSON)
            completion(Result.Success(surveys!))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func survey(surveyID id: Int, completion: Result<Survey?> -> Void) {
    Alamofire.request(Router.Survey(id: id))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            let survey = Mapper<Survey>().map(JSON)
            completion(Result.Success(survey!))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func vote(surveyID id: Int, userID: Int, optionID: Int, completion: Result<String?> -> Void) {
    Alamofire.request(Router.SurveyVote(id: id, ["user": userID, "option": optionID]))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            completion(Result.Success(status!.message))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func replies(surveyID id: Int, completion: Result<Replies?> -> Void) {
    APIReply.replies(type: Constant.FiegSurvey, id: id, completion: completion)
  }

  class func newReply(surveyID id: Int, userID: Int, reply: String, completion: Result<String?> -> Void) {
    APIReply.newReply(type: Constant.FiegSurvey, id: id, user: userID, reply: reply, completion: completion)
  }

  class func deleteReply(replyID id: Int, completion: Result<String?> -> Void) {
    APIReply.delete(type: Constant.FiegSurvey, id: id, completion: completion)
  }

}

// MARK: - Calendar Class
class APICalendar {

  class func calendars(month: Month, year: Year, completion: Result<Calendars?> -> Void) {
    Alamofire.request(Router.Calendars(["month": month.rawValue, "year": year.rawValue]))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            let calendars = Mapper<Calendars>().map(JSON)
            completion(Result.Success(calendars!))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func vote(calendarID id: Int, userID: Int, option: Option, completion: Result<String?> -> Void) {
    Alamofire.request(Router.SurveyVote(id: id, ["user": userID, "option": option.rawValue]))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            completion(Result.Success(status!.message))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func replies(calendarID id: Int, completion: Result<Replies?> -> Void) {
    APIReply.replies(type: Constant.FiegCalendar, id: id, completion: completion)
  }

  class func newReply(calendarID id: Int, userID: Int, reply: String, completion: Result<String?> -> Void) {
    APIReply.newReply(type: Constant.FiegCalendar, id: id, user: userID, reply: reply, completion: completion)
  }

  class func deleteReply(calendarID id: Int, completion: Result<String?> -> Void) {
    APIReply.delete(type: Constant.FiegCalendar, id: id, completion: completion)
  }

}

// MARK: - Reply Class
private class APIReply {

  class func replies(type type: String, id: Int, completion: Result<Replies?> -> Void) {
    Alamofire.request(Router.Reply(type: type, id: id))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            let replies = Mapper<Replies>().map(JSON)
            completion(Result.Success(replies!))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func newReply(type type: String, id: Int, user: Int, reply: String, completion: Result<String?> -> Void) {
    Alamofire.request(Router.ReplyNew(type: type, id: id, ["user": user, "text": reply]))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            completion(Result.Success(status!.message))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

  class func delete(type type: String, id: Int, completion: Result<String?> -> Void) {
    Alamofire.request(Router.ReplyDelete(type: type, id: id))
      .responseJSON(completionHandler: { response in
        switch response.result {
        case .Success(let JSON):
          let status = Mapper<Error>().map(JSON)
          if status!.error as Bool {
            completion(Result.Error(status!.message))
          } else {
            completion(Result.Success(status!.message))
          }
        case .Failure(let error):
          completion(Result.Error(Utils.stringFromError(error as NSError)))
        }
      })
  }

}