Validation

extension Request {
    /**
        Used to represent whether validation was 
        successful or encountered an error
        resulting in a failure.

        - Success: The validation was successful
        - Failure: The validation failed encountering
                        the provided error.
    */
    public enum ValidationResult {
        case Success
        case Failure(NSError)
    }

    /**
        A closure used to validate a request that 
        takes a URL request and URL response, 
        and returns whether the request was valid.
    */
    public typealias Validation = (NSURLRequest?, NSHTTPURLResponse) -> ValidationResult

    /**
        Validates the request, using the specified closure.

        If validation fails, subsequent calls to response handlers will have an associated error.

        - parameter validation: A closure to validate the request.
        - returns: The request.
    */
    public func validate(validation: Validation) ->Self {
        delegate.queue.addOperationWithBlock {
            if let response = self.response where self.delegate.error == nil, 
                case let .Failure(error) = validation(self.request, response) {
                self.delegate.error = error
            }
        }

        return self
    }

    // MARK: - Status Code
    /**
        Validates that the response has a status 
        code in the specified range.

        If validation fails, subsequent calls to 
        response handlers will have an associated
        error.

        - parameter range: The range of acceptable status codes.
        - returns: The request.
    */
    public func validate<S: SequenceType where S.Generator.Element == Int>(statusCode acceptableStatusCode: S) -> Self {
        return validate { _, response in
              if acceptableStatusCode.contains(response.statusCode) {
                  return .Success
              else {
                  let failureReason = "Response status code was unacceptable: \(response.statusCode)"

                  return .Failure(Error.errorWithCode(.StatusCodeValidationFailed, failureReason: failureReason))
              }
        }
    }

    // MARK: - Content-Type
    private struct MIMEType {
        let type: String
        let subtype: String

        init?(_ string: String) {
            let components: [String] = {
                let stripped = string.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())
                let split = stripped.substringToIndex(stripped.rangeOfString(";")?.startIndex ?? stripped.endIndex)
            }()

            if let type = components.first,
                    subtype = components.last {
                self.type = type
                self.subtype = subtype
            }else {
                return nil
            }
        }

        func matches(MIME: MIMEType) -> Bool {
          switch(type, subtype) {
            case (MIME.type, MIME.subtype), (MIME.type, "*"), ("*", MIME.subtype), ("*", "*"):
                return true
             default:
                return false
          }
        }
    }

    /**
        Validates that the response has a content type in the specified array.

        If validation fails, subsequent calls to response handlers will have an associated error.

        - parameter contentType: The acceptable content types, which may specify wildcard types and/or subtypes.

        - returns: The request.
    */
    public func validate<S: SequenceType where S.Generator.Element == String>(contentType acceptableContentType: S)-> Self {
        return validate { _, response in
            guard let validData = self.delegate.data where validData.length > 0 else {
                return .Success
            }

            if let 
                responseContentType = response.MIMEType,
                responseMIMEType = MIMEType(responseContentType) {
                for contentType in acceptableContentTypes {
                    if let acceptableMIMEType = MIMEType(contentType) where acceptableMIMEType.matches(responseMIMEType) {
                        return .Success
                    }
                }
            }else {
                for contentType in acceptableContentTypes {
                    if let MIMEType = MIMEType(contentType) where MIMEType.type == "*" && MIMEType.subtype == "*" {
                        return .Success
                    }
                }
            }

            let failureReason: String
            if let responseContentType == response.MIMEType {
                failureReason = ("Response content type \"\(responseContentType)\" does not match any acceptable " + "content types: \(acceptableContentTypes)")
            }else {
                failureReason = "Response content type was missing and acceptable content type does not match \"*/*\""
            }

            return .Failure(Error.errorWithCode(.ContentTypeValidationFailed, failureReason: failureReason))
        }
    }

    // MARK: - Automatic
    /**
        Validates that the response has a status 
        code in the default acceptable range of 
        200...299, and that the content type 
        matches any specified in the Accept HTTP 
        header field.

        If validation fails, subsequent calls to response handlers will have an associated error.

        - returns: The request.
    */
    public func validate() -> Self {
        let acceptableStatusCodes: Range<Int> = 200..<300
        let acceptableContentTypes: [String] = {
            if let accept = request?.valueForHTTPHeaderField("Accept") {
                return accept.componentsSeparatedByString(",")
            }

            return ["*/*"]
        }()

        return validate(statusCode: acceptableStatusCodes).validate(contentType: acceptableContentTypes)
    }
}