/**
 * @file ProcessSession.h
 * ProcessSession class declaration
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef __PROCESS_SESSION_H__
#define __PROCESS_SESSION_H__

#include <uuid/uuid.h>
#include <vector>
#include <queue>
#include <map>
#include <mutex>
#include <atomic>
#include <algorithm>
#include <set>

#include "Logger.h"
#include "Processor.h"
#include "ProcessContext.h"
#include "FlowFileRecord.h"
#include "Exception.h"

//! ProcessSession Class
class ProcessSession
{
public:
	//! Constructor
	/*!
	 * Create a new process session
	 */
	ProcessSession(ProcessContext *processContext = NULL) : _processContext(processContext) {
		_logger = Logger::getLogger();
		_logger->log_trace("ProcessSession created for %s", _processContext->getProcessor()->getName().c_str());
	}
	//! Destructor
	virtual ~ProcessSession() {}
	//! Commit the session
	void commit();
	//! Roll Back the session
	void rollback();
	//!
	//! Get the FlowFile from the highest priority queue
	FlowFileRecord *get();
	//! Create a new UUID FlowFile with no content resource claim and without parent
	FlowFileRecord *create();
	//! Create a new UUID FlowFile with no content resource claim and inherit all attributes from parent
	FlowFileRecord *create(FlowFileRecord *parent);
	//! Clone a new UUID FlowFile from parent both for content resource claim and attributes
	FlowFileRecord *clone(FlowFileRecord *parent);
	//! Clone a new UUID FlowFile from parent for attributes and sub set of parent content resource claim
	FlowFileRecord *clone(FlowFileRecord *parent, long offset, long size);
	//! Duplicate a FlowFile with the same UUID and all attributes and content resource claim for the roll back of the session
	FlowFileRecord *duplicate(FlowFileRecord *orignal);
	//! Transfer the FlowFile to the relationship
	void transfer(FlowFileRecord *flow, Relationship relationship);
	//! Put Attribute
	void putAttribute(FlowFileRecord *flow, std::string key, std::string value);
	//! Remove Attribute
	void removeAttribute(FlowFileRecord *flow, std::string key);
	//! Remove Flow File
	void remove(FlowFileRecord *flow);
	//! Execute the given read callback against the content
	void read(FlowFileRecord *flow, InputStreamCallback *callback);
	//! Execute the given write callback against the content
	void write(FlowFileRecord *flow, OutputStreamCallback *callback);
	//! Execute the given write/append callback against the content
	void append(FlowFileRecord *flow, OutputStreamCallback *callback);
	//! Penalize the flow
	void penalize(FlowFileRecord *flow);
	//! Import the existed file into the flow
	void import(std::string source, FlowFileRecord *flow, bool keepSource = true, uint64_t offset = 0);

protected:
	//! FlowFiles being modified by current process session
	std::map<std::string, FlowFileRecord *> _updatedFlowFiles;
	//! Copy of the original FlowFiles being modified by current process session as above
	std::map<std::string, FlowFileRecord *> _originalFlowFiles;
	//! FlowFiles being added by current process session
	std::map<std::string, FlowFileRecord *> _addedFlowFiles;
	//! FlowFiles being deleted by current process session
	std::map<std::string, FlowFileRecord *> _deletedFlowFiles;
	//! FlowFiles being transfered to the relationship
	std::map<std::string, Relationship> _transferRelationship;
	//! FlowFiles being cloned for multiple connections per relationship
	std::map<std::string, FlowFileRecord *> _clonedFlowFiles;

private:
	// Clone the flow file during transfer to multiple connections for a relationship
	FlowFileRecord* cloneDuringTransfer(FlowFileRecord *parent);
	//! ProcessContext
	ProcessContext *_processContext;
	// Prevent default copy constructor and assignment operation
	// Only support pass by reference or pointer
	ProcessSession(const ProcessSession &parent);
	ProcessSession &operator=(const ProcessSession &parent);
	//! Logger
	Logger *_logger;

};

#endif