import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import mcdr.objects.impl.ObjectMotionWordNMatches;
import mcdr.objects.utils.RankedSortedCollectionDistHashcode;
import mcdr.sequence.SequenceMocap;
import mcdr.sequence.SequenceMotionWords;
import mcdr.sequence.impl.SequenceMocapPoseCoordsL2DTW;
import mcdr.sequence.impl.SequenceMotionWordsNMatchesDTW;
import mcdr.test.utils.ObjectCategoryMgmt;
import mcdr.test.utils.ObjectMgmt;
import messif.objects.LocalAbstractObject;
import messif.objects.util.RankedAbstractObject;
import messif.operations.AnswerType;
import messif.operations.query.KNNQueryOperation;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Petra Budikova, budikova@fi.muni.cz, FI MU Brno, Czech Republic
 */
public class DPHamala {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {    
        
        /************** Load motion data in different formats *********************/
        // MoCap data     
        final String dataFilepath = "y:/datasets/mocap/hdm05/class130-actions-coords_normPOS-fps12.data";                       
        final Class dataClass = SequenceMocapPoseCoordsL2DTW.class;
        //hMWs
//        final String dataFilepath = "y://datasets//mocap//hdm05//motion_words//quantized//hdm05-annotations_specific-segment80_shift16-coords_normPOS-fps12-quantized-pivots-kmedoids-350.data";        
//        final Class dataClass = SequenceMotionWordsDTW.class;
        //sMWs
//        final String dataFilepath = "Y:\\datasets\\mocap\\hdm05\\motion_words\\quantized-class130-actions-coords_normPOS-fps12-segment80-shift16\\kmedoids-350-softassign-D20K6.data";        
//        final Class dataClass = SequenceMotionWordsSoftAssignmentDTW.class;
//        ObjectMotionWordSoftAssignment.maxPartsToMatch = 6;
        //moMWs
//        final String dataFilepath = "y:/datasets/mocap/hdm05/motion_words/quantized/hdm05-annotations_specific-segment80_shift16-coords_normPOS-fps12-quantized-overlays5-pivots-kmedoids-350.data";        
//        final Class dataClass = SequenceMotionWordsNMatchesDTW.class;        
//        ObjectMotionWordNMatches.nMatches = 1;
//        ObjectMotionWordNMatches.maxPartsToMatch = 5;        

        ObjectCategoryMgmt mwCategoryMgmt = new ObjectCategoryMgmt();
        ObjectMgmt motionSequenceMgmt = new ObjectMgmt(mwCategoryMgmt);
        motionSequenceMgmt.read(dataClass, dataFilepath);
        
        
        /************** Evaluate distance (i.e., dissimilarity) of two objects *********************/
        Iterator<LocalAbstractObject> sequenceIt = motionSequenceMgmt.getObjects().iterator();        
        LocalAbstractObject sequence1 = sequenceIt.next();
        LocalAbstractObject sequence2 = sequenceIt.next();
        float distance = sequence1.getDistance(sequence2);
        System.out.println("\n***** Example of distance computation *****");
        System.out.println("Distance between sequences "+sequence1.getLocatorURI()+" and "+sequence2.getLocatorURI()+" is "+distance);
        System.out.println("The category of object "+sequence1.getLocatorURI()+" is "+motionSequenceMgmt.parseObjectCategoryId(sequence1));        
        System.out.println("*******************************************\n");

        
        /************** Evaluate kNN search for all objects *********************/          
        sequenceIt = motionSequenceMgmt.getObjects().iterator();
        int hdm05ActionCount = motionSequenceMgmt.getObjectCount();
        int currentQueryNumber = 0;
        Float sumOfPrecision = 0f;
        while (sequenceIt.hasNext()) {
            LocalAbstractObject querySequence = sequenceIt.next();
            currentQueryNumber++;
            String queryCategoryId = motionSequenceMgmt.parseObjectCategoryId(querySequence);
            Integer queryCategorySize = motionSequenceMgmt.getObjectCountInCategory(motionSequenceMgmt.getCategoryById(queryCategoryId));
            //there is one category of size 1, obviously a k*NN query makes no sense here, so we are skipping this object
            if (queryCategorySize<2) { 
                System.out.println("Skipping query "+querySequence.getLocatorURI()+" because it has category size "+queryCategorySize);
                continue;
            }
            System.out.println("Processing query "+currentQueryNumber+"/"+hdm05ActionCount+": "+querySequence.getLocatorURI()+", category size "+queryCategorySize);
            //we run kNN search with k=(size of the query object's category - 1); 
            //in the optimal case, it well return all the other objects from the same category
            KNNQueryOperation op = new KNNQueryOperation(querySequence, queryCategorySize-1, false, AnswerType.ORIGINAL_OBJECTS, new RankedSortedCollectionDistHashcode());
            for (LocalAbstractObject dataObject : motionSequenceMgmt.getObjects()) {
                if (!dataObject.getLocatorURI().equals(querySequence.getLocatorURI())) {
                    op.addToAnswer(dataObject, querySequence.getDistance(dataObject), null);
                }
            }
            // compute average precision of the results
            Iterator<RankedAbstractObject> answerIt = op.getAnswer();
            float correctResultsCount = 0;
            System.out.print("  Answer: ");
            while (answerIt.hasNext()) {
                RankedAbstractObject resultObject = answerIt.next();
                System.out.print(resultObject.getObject().getLocatorURI()+"("+resultObject.getDistance()+") ");
                String resultCategoryId = motionSequenceMgmt.getObjectCategories((LocalAbstractObject)resultObject.getObject()).get(0).id;
                if (queryCategoryId.equals(resultCategoryId)) {
                    correctResultsCount++;
                }
            } 
            System.out.println("\n  Precision: "+correctResultsCount/(queryCategorySize-1));
            sumOfPrecision += correctResultsCount/(queryCategorySize-1); 
        }
        System.out.println("Average precision: "+(sumOfPrecision/(motionSequenceMgmt.getObjects().size()-2)));

        
    }
}