/// Convert String to Int
class ConvertOperation: ChainableOperationBase<String, Int> {
    
    override func process(inputData: String, success: (Int) -> (), failure: (Error) -> ()) {
        if let result = Int(inputData) {
            success(result)
        } else {
            failure(NSError(domain: "com.incetro.Lagoon.Example", code: 1, userInfo: nil))
        }
    }
}

/// Increment the given number
class IncrementOperation: ChainableOperationBase<Int, Int> {
    
    override func process(inputData: Int, success: (Int) -> (), failure: (Error) -> ()) {
        success(inputData + 1)
    }
}

/// Decrement the given number
class DecrementOperation: ChainableOperationBase<Int, Int> {
    
    override func process(inputData: Int, success: (Int) -> (), failure: (Error) -> ()) {
        success(inputData - 1)
    }
}

/// Multiply the given number
class MultiplicationOperation: ChainableOperationBase<Int, Int> {
    
    let mult: Int
    
    init(with mult: Int) {
        self.mult = mult
    }
    
    override func process(inputData: Int, success: (Int) -> (), failure: (Error) -> ()) {
        success(inputData * self.mult)
    }
}

/// Make array of digits from the given number
class ArrayOperation: ChainableOperationBase<Int, [Int]> {
    
    override func process(inputData: Int, success: ([Int]) -> (), failure: (Error) -> ()) {
        
        var result: [Int] = []
        var number = inputData
        
        while number > 0 {
            result.append(number % 10)
            number = number / 10
        }
        
        success(result.reversed())
    }
}

let strings = ["123", "4", "56a", "a", ""]
        
for string in strings {
            
    let convert   = ConvertOperation()
    let increment = IncrementOperation()
    let decrement = DecrementOperation()
    let mult      = MultiplicationOperation(with: 125)
    let array     = ArrayOperation()
            
    /// Create chain
    let operations = [convert, increment, decrement, mult, array]
            
    /// We expect Int array as output type
    let compoundOperation = CompoundOperation.default(withOutputDataType: [Int].self)
    
    /// Setup compound operation
    compoundOperation.configure(withChainableOperations: operations, inputData: string, success: { result in
        print(result)
    }, failure: { error in
        print(error.localizedDescription)
    })
    
    /// Start it!
    Lagoon.add(operation: compoundOperation)
}

// MARK: - RequestDataSigningOperation
class RequestDataSigningOperation: ChainableOperationBase<RequestDataModel, RequestDataModel> {
    
    private let requestSigner: RequestDataSigner
    
    init(withRequestSigner requestSigner: RequestDataSigner) {
        self.requestSigner = requestSigner
    }
    
    override func process(inputData: RequestDataModel, success: (RequestDataModel) -> (), failure: (Error) -> ()) {
        let signedRequestDataModel = requestSigner.signRequestDataModel(inputData)
        success(signedRequestDataModel)
    }
}

// MARK: - RequestConfigurationOperation
class RequestConfigurationOperation: ChainableOperationBase<RequestDataModel, URLRequest> {
    
    private let requestConfigurator: RequestConfigurator
    private let method: HTTPMethod
    private let serviceName: String?
    private let urlParameters: [String]
    private let queryType: QueryType
    
    init(configurator: RequestConfigurator, method: HTTPMethod, type: QueryType, serviceName: String?, urlParameters: [String]) {
        self.method = method
        self.queryType = type
        self.serviceName = serviceName
        self.urlParameters = urlParameters
        self.requestConfigurator  = configurator
    }
    
    // MARK: - ChainableOperationBase
    
    override func process(inputData: RequestDataModel, success: (URLRequest) -> (), failure: (Error) -> ()) {
        
        let request = requestConfigurator.createRequest(withMethod:       self.method,
                                                        type:             self.queryType,
                                                        serviceName:      self.serviceName,
                                                        urlParameters:    self.urlParameters,
                                                        requestDataModel: inputData)
        
        success(request)
    }
}

/// And other operations...
/// Then use it to make network chain

let operations = [
    requestDataSigningOperation,
    requestConfigurationOperation,
    networkRequestOperation,
    deserializationOperation,
    validationOperation,
    responseCachingOperation,
    responseMappingOperation
]

let compoundOperation = CompoundOperation.default(withOutputDataType: User.self)
compoundOperation.maxConcurrentOperationCount = 1
compoundOperation.configure(withChainableOperations: operations, inputData: inputData, success: success, failure: failure)
Lagoon.add(operation: compoundOperation)