#ifndef TRIPLETS_OPTIONS_H_
#define TRIPLETS_OPTIONS_H_

#include "util.h"

/** strategy for parallel execution of bunches used */
enum BunchStrategy {
	/** dynamic parallelism, default */
	BunchDynamic = 0,
	/** thread block parallelism */
	BunchThreadBlock = 1,
	/** host stream parallelism */
	BunchHostStream = 2,
	/** host parallelism with streams and threads */
	BunchHostStreamThread = 3
};

/** mode for comparison of tracks against tubes */
enum TubeTestStrategy {
	/** raster comparison strategy, default */
	TubeTestRaster = 0,
	/** brute-force comparsion strategy using shared memory */
	TubeTestShared = 1
};

/** mode for comparison of tracks against skewlets */
enum SkewletTestStrategy {
	/** brute-force comparison, default as it is the fastest */
	SkewletTestAll = 0,
	/** skewlet binning, disabled as it is slower */
	SkewletTestBins = 1
};


// masks and offsets of various flags components
#define VERBOSITY_OFFSET 0
#define VERBOSITY_MASK 3
#define BUNCH_STRATEGY_OFFSET (VERBOSITY_OFFSET + 2)
#define BUNCH_STRATEGY_MASK 3
#define TUBE_STRATEGY_OFFSET (BUNCH_STRATEGY_OFFSET + 2)
#define TUBE_STRATEGY_MASK 1
#define GROUP_ON_DEVICE_OFFSET (TUBE_STRATEGY_OFFSET + 1)
#define GROUP_ON_DEVICE_MASK 1
#define SKEWLET_STRATEGY_OFFSET (GROUP_ON_DEVICE_OFFSET + 1)
#define SKEWLET_STRATEGY_MASK 1

/** options for triplet finder algorithm */
struct TripletFinderOptions {
	/** default constructor to be available both on host and on device; this is
			needed to be able to use the options in the main class */
	__host__ __device__ TripletFinderOptions() {}
	
	TripletFinderOptions(bool dummy) : 
		tubes_path("data/stt-tubes.csv"), hits_path("data/stt-hits.csv"),
		tracks_path("tracks-found.csv"), flags(0), nhits(-1), tbunch(1000), idevice(0)
	  {
 #if !WITH_DYN_PAR
 			set_bunch_strategy(BunchHostStream);
 #endif
		}
	/** parses the command line */
	void parse_cmdline(int argc, char **argv);
	//@region flags functions; setting possible on host only
	//@{
	/** get verbosity */
	hostdevice__ int verbosity(void) const { 
		return (flags >> VERBOSITY_OFFSET) & VERBOSITY_MASK;
	}
	/** set verbosity */
	void set_verbosity(int v) {
		flags &= ~(VERBOSITY_MASK << VERBOSITY_OFFSET);
		flags |= (v & VERBOSITY_MASK) << VERBOSITY_OFFSET;
	}
	/** get bunching strategy */
	hostdevice__ BunchStrategy bunch_strategy(void) const {
		return BunchStrategy((flags >> BUNCH_STRATEGY_OFFSET) & 
												 BUNCH_STRATEGY_MASK);
	}
	/** set bunching strategy */
	void set_bunch_strategy(BunchStrategy s) {
		flags &= ~(BUNCH_STRATEGY_MASK << BUNCH_STRATEGY_OFFSET);
		flags |= (s & BUNCH_STRATEGY_MASK) << BUNCH_STRATEGY_OFFSET;
	}
	/** get tube test strategy */
	hostdevice__ TubeTestStrategy tube_strategy(void) const {
		return TubeTestStrategy((flags >> TUBE_STRATEGY_OFFSET) & 
														TUBE_STRATEGY_MASK);
	}
	/** set tube test strategy */
	void set_tube_strategy(TubeTestStrategy s) {
		flags &= ~(TUBE_STRATEGY_MASK << TUBE_STRATEGY_OFFSET);
		flags |= (s & TUBE_STRATEGY_MASK) << TUBE_STRATEGY_OFFSET;
	}
	/** get whether to do initial hit grouping on device */
	hostdevice__ bool group_on_device(void) const {
		return TubeTestStrategy((flags >> GROUP_ON_DEVICE_OFFSET) & 
														GROUP_ON_DEVICE_MASK);
	}
	void set_group_on_device(bool s) {
		flags &= ~(GROUP_ON_DEVICE_MASK << GROUP_ON_DEVICE_OFFSET);
		flags |= ((int)s & GROUP_ON_DEVICE_MASK) << GROUP_ON_DEVICE_OFFSET;
	}
	/** get skewlet test strategy */
	hostdevice__ SkewletTestStrategy skewlet_strategy(void) const {
		return SkewletTestStrategy((flags >> SKEWLET_STRATEGY_OFFSET) & 
														SKEWLET_STRATEGY_MASK);
	}
	/** set tube test strategy */
	void set_skewlet_strategy(SkewletTestStrategy s) {
		flags &= ~(SKEWLET_STRATEGY_MASK << SKEWLET_STRATEGY_OFFSET);
		flags |= (s & SKEWLET_STRATEGY_MASK) << SKEWLET_STRATEGY_OFFSET;
	}
	/** set whether to do initial hit grouping on device */
	//@}
	/** path to tubes file */
	const char *tubes_path;
	/** path to hits file */
	const char *hits_path;
	/** path to output track file */
	const char *tracks_path;
	/** flags associated with the options */
	unsigned flags;
	/** the number of hits actually used from the input file, with -1 meaning that
			all hits are used */
	int nhits;
	/** device to be used for processing */
	int idevice;
	/** the bunch core time, ns */
	float tbunch;
};  // TripletFinderOptions

#endif