#! /bin/bash
#
# Load json ArGaze context file ($1) then, look for all Tobii record segments into input folder ($2).
#
# For each Tobii record segment found: 
# - context "segment" field is modified to bind on it,
# - context "pipeline" field is modified to bind on a temporary patched pipeline \ 
#	resulting from the merging of the given pipeline and an optionnal "patch.json" file in Tobii record segment,
# - pipeline "projection_cache" field is added to create or bind a "layers_projection.csv" file in segment folder,
# - then, ArGaze executes the modified context from output folder ($3) to export all records into it,
# - finally, context and pipeline files are resetted and temporary patched pipeline is removed.
#
# Arguments:
# $1: ArGaze context file
# $2: folder from where to look for Tobii records
# $3: folder where to export processing outputs
#######################################

# Check required arguments
if [ "$#" -ne 3 ]; then
  echo "!!! Incorrect number of arguments"
  exit 1
fi

context_file=$1
input_folder=$2
output_folder=$3

# Check requirements:
if brew ls --versions jq > /dev/null; then
 	: # jq installed
else
	echo "*** Installing jq package"
 	brew install jq
fi

ctx_folder="$(dirname "$context_file")"

#######################################
# Process Tobii segment folder
# Arguments:
#   $1: Path to Tobii segment
#######################################
function process_segment() {

	local rec_id=$1
	local seg_folder=$2
	local seg_id=$(basename $seg_folder)
	local seg_length=$(jq .seg_length $seg_folder/segment.json)

	local ca_state=$(jq -r .ca_state $seg_folder/calibration.json)

	echo "- Segment $seg_id:"
	echo "	- Lenght: $seg_length"
	echo "	- Calibration: $ca_state"

	# Move to context folder
	cd $ctx_folder

	# Create temporary context file
	temp_context_file=".$rec_id-$seg_id.context.json"
	yes | cp -f $context_file $temp_context_file
	ctx_class=$(jq "keys[0]" $temp_context_file)
	ctx_name=$(jq .$ctx_class.name $temp_context_file)
	ctx_pipeline=$(jq -r .$ctx_class.pipeline $temp_context_file)

	echo "- Context $(basename $temp_context_file):"
	echo "	- Name: $ctx_name"

	# Create temporary pipeline file 
	temp_pipeline_file=".$rec_id-$seg_id.pipeline.json"
	yes | cp -f $ctx_pipeline $temp_pipeline_file
	ppl_class=$(jq "keys[0]" $temp_pipeline_file)
	ppl_name=$(jq .$ppl_class.name $temp_pipeline_file)

	echo "- Pipeline: $(basename $temp_pipeline_file)"
	echo "	- Name: $ppl_name"

	# Modify temporary context segment
	echo "$(jq --tab ".$ctx_class.segment = \"$seg_folder\"" $temp_context_file)" > "$ctx_folder/$temp_context_file"

	# Modify temporary context pipeline
	echo "$(jq --tab ".$ctx_class.pipeline = \"$temp_pipeline_file\"" $temp_context_file)" > "$ctx_folder/$temp_context_file"

	# Modify temporary pipeline projection_cache
	echo "$(jq --tab ".$ppl_class.projection_cache = \"$seg_folder/layers_projection.csv\"" $temp_pipeline_file)" > "$ctx_folder/$temp_pipeline_file"

	# Check patch
	patch_file="$seg_folder/patch.json"
	if [ -f "$patch_file" ]; then
		
		echo "	+ Patch:"
		echo "$(jq . $patch_file)"

		# Merge patch with temporary pipeline
		echo "$(jq --tab -s ".[0] * .[1]" $temp_pipeline_file $patch_file)" > "$ctx_folder/$temp_pipeline_file"
	fi

	# Create segment output folder
	seg_output=$output_folder/$rec_id/segments/$seg_id
	mkdir -p $seg_output
	cd $seg_output

	# Launch modified context with argaze load command 
	echo "*** ArGaze starts context"

	python -m argaze load "$ctx_folder/$temp_context_file"

	echo "*** ArGaze ends context"

	# Move back to context folder
	cd $ctx_folder

	# Delete temporary context file
	rm "$ctx_folder/$temp_context_file"

	# Delete temporary pipeline file
	rm "$ctx_folder/$temp_pipeline_file"
}

#######################################
# Process Tobii record folder
# Arguments:
#   $1: Path to Tobii record
#######################################
function process_record() {

	local rec_folder=$1
	local rec_id=$(basename $rec_folder)
	local rec_name=$(jq .rec_info.Name $rec_folder/recording.json)

	local pa_id=$(jq .pa_id $rec_folder/participant.json)
	local pa_name=$(jq .pa_info.Name $rec_folder/participant.json)

	echo "*** Loading record $rec_id:"
	echo "- Name: $rec_name"
	echo "- Participant:"
	echo "	- Id: $pa_id"
	echo "	- Name: $pa_name"

	for segment in $rec_folder/segments/*; do
		process_segment $rec_id "$rec_folder/segments/$(basename $segment)"
	done
}

echo "*** Looking for Tobii records into $2 folder"

# Check if the path is directly a path to a record segment
if [ -f "$input_folder/livedata.json.gz" ]; then

	process_record "$(dirname "$(dirname "$input_folder")")"

# Otherwise, look for all Tobii record segment
else

	for tobii_data in $input_folder/**/segments/*/livedata.json.gz; do
	    process_record "$(dirname "$(dirname "$(dirname "$tobii_data")")")"
	done

fi