function [recognitionRate, missData] = stressClassify(data, mode)

% mode 1 for show confusion table & Excel file writing & Recognition Rate output
% mode 2 for only Recognition Rate output

%% ================= Parameter Setting
warning off;
prm;

if mode==1
    confPlotOpt = 1;
    xlsOpt = 1;
elseif mode==2
    confPlotOpt = 0;
    xlsOpt = 0;
    errorAnaly = 0;
end

feaDim = size(data.input(:,1), 1);
fprintf('\nDimension of Feature = %d\n', feaDim);
fprintf('%d-fold cross validation\n\n', trainOpt.foldNum);
recognitionRate = [];

%% ================= Training
for classifierNum = 1:length(trainOpt.classifier)
   
    OnePart = round(length(data.name)/trainOpt.foldNum);
    dataNum = length(data.name);
    predictPart = [];
    gtPart = [];
    allConf.predictPos = [];
    allConf.gtPos = [];
    
    sylConf.pos2 = [];
    sylConf.pos3 = [];
    sylConf.pos4 = [];
    sylConf.pos5 = [];
    sylConf.pos6 = [];
    sylConf.pos7 = [];
    sylConf.pos8 = [];
    
    sylConf.gt2 = [];
    sylConf.gt3 = [];
    sylConf.gt4 = [];
    sylConf.gt5 = [];
    sylConf.gt6 = [];
    sylConf.gt7 = [];
    sylConf.gt8 = [];
    
    RecogAccuracySyl = zeros(1, trainOpt.foldNum);      % Syllable-wise accuracy
    RecogAccuracyWord = zeros(1, trainOpt.foldNum);     % Word-wise accuracy
    wordArray = {};
    
    missDataIdx = [];           % for error analysis
    missDataSylNum = [];        % for error analysis
    missDataSylPos = [];        % for error analysis
    missDataComputedPos = [];   % for error analysis
                       
    for i = 1:trainOpt.foldNum
        
        data2 = data;
        %keyboard;
        testRange = [OnePart*(i-1)+1, min(OnePart*i, dataNum)];     % Word index
        testStartId = min(find(data.id==testRange(1)));             
        testEndId = max(find(data.id==testRange(2)));               
        wordArray = {wordArray; data.name(testRange(1):testRange(2))};

        testData.input = data2.input(:, testStartId:testEndId);
        testData.output = data2.output(testStartId:testEndId);
        testID = data2.id(testStartId:testEndId);

        data2.input(:, testStartId:testEndId) = [];
        data2.output(:, testStartId:testEndId) = [];
        
              %% ======== Classifier option
        fprintf('Classifier = %s, Training  fold %d / %d\n', trainOpt.classifier{classifierNum}, i, trainOpt.foldNum);

        switch(trainOpt.classifier{classifierNum})
            
            case 'svmc'
                addpath toolbox/libsvm-3.20/matlab;
                svm.prm = '-t 2 -c 1';
                svmModel = svmtrain(data2.output', data2.input', svm.prm);
                [computedClass, ~, probEst] = svmpredict(testData.output', testData.input', svmModel);
                computedClass = computedClass';
                
            case 'qc'
                opt = [];
                opt.prior = [1, 1];
                cPrm = qcTrain(data2, opt);
                [computedClass, probEst] = qcEval(testData, cPrm, showPlot);

            case 'nbc'
                opt = [];
                opt.prior = [1, 1];
                cPrm = nbcTrain(data2, opt);
                [computedClass, probEst] = nbcEval(testData, cPrm, showPlot);

            case 'src'
                opt = srcTrain('defaultOpt');
                cPrm = srcTrain(data2, opt);
                [computedClass, probEst] = srcEval(testData, cPrm, showPlot);

            case 'gmmc'
                gaussianNumList = [2, 4, 8, 16, 32];
                gmmPrm = gmmTrain('defaultOpt');
                gmmPrm.config.covType = 2;

                GmmRecogAccuracySyl = zeros(length(gaussianNumList), trainOpt.foldNum);
                GmmRecogAccuracyWord = zeros(length(gaussianNumList), trainOpt.foldNum);
                meanAccuracySyl = zeros(length(gaussianNumList));
                meanAccuracyWord = zeros(length(gaussianNumList));
                
                for Num = 1:length(gaussianNumList)
                    gmmPrm.config.gaussianNum = gaussianNumList(Num);
                    gtPart = [];
                    predictPart = [];
                    allConf.predictPos = [];
                    allConf.gtPos = [];
                    wordArray = {};
                    
                    for k = 1:trainOpt.foldNum
                        fprintf('GMM training, Gaussian Number = %d  fold %d\n', gaussianNumList(Num), k);
                        data2 = data;
                        testRange = [OnePart*(k-1)+1, min(OnePart*k, dataNum)];
                        testStartId = min(find(data.id==testRange(1)));
                        testEndId = max(find(data.id==testRange(2)));
                        wordArray = {wordArray; data.name(testRange(1):testRange(2))};

                        testData.input = data2.input(:, testStartId:testEndId);
                        testData.output = data2.output(testStartId:testEndId);
                        testID = data2.id(testStartId:testEndId);

                        data2.input(:, testStartId:testEndId) = [];
                        data2.output(:, testStartId:testEndId) = [];

                        cPrm = gmmcTrain(data2, gmmPrm, showPlot);
                        cPrm.prior = [1, 1];
                        [computedClass, probEst] = gmmcEval(testData, cPrm, showPlot);

                        [computedClass_Word, correctCount, allConf, sylConf, hitIndex, missIndex, missResult] = classifyPostprocess(trainOpt.classifier{classifierNum}, testID, testData.output, computedClass, probEst, data, allConf, sylConf);
                        GmmRecogAccuracySyl(Num, k) = sum(computedClass_Word==testData.output) / (testEndId-testStartId+1);
                        GmmRecogAccuracyWord(Num, k) = correctCount / (testRange(2)-testRange(1)+1);
                        gtPart = [gtPart, testData.output];
                        predictPart = [predictPart, computedClass];

                        fprintf('Syllable-wise Accuracy = %.2f %%\n', GmmRecogAccuracySyl(Num, k)*100);
                        fprintf('Word-wise Accuracy = %.2f %%\n\n', GmmRecogAccuracyWord(Num, k)*100);
                        
                    end
                end
                
                for Num = 1:length(gaussianNumList)
                    meanAccuracySyl(Num) = mean(GmmRecogAccuracySyl(Num, :))*100;
                    meanAccuracyWord(Num) = mean(GmmRecogAccuracyWord(Num, :))*100;
                    fprintf('Gaussian Number = %d, Syllable-wise Accuracy = %.2f %% , Word-wise Accuracy = %.2f %% , Classifier = %s , %d-fold cross validation\n', gaussianNumList(Num), meanAccuracySyl(Num), meanAccuracyWord(Num), trainOpt.classifier{classifierNum}, trainOpt.foldNum);
                end
                
                break;
        end
              %% ================= Postprocessing
        if ~strcmp(trainOpt.classifier{classifierNum}, 'gmmc')      % Classifier~=GMM
            
            [computedClass_Word, correctCount, allConf, sylConf, hitIndex, missIndex, missResult] = classifyPostprocess(trainOpt.classifier{classifierNum}, testID, testData.output, computedClass, probEst, data, allConf, sylConf);
            RecogAccuracySyl(i) = sum(computedClass_Word==testData.output) / (testEndId-testStartId+1);
            RecogAccuracyWord(i) = correctCount / (testRange(2)-testRange(1)+1);
            gtPart = [gtPart, testData.output];
            predictPart = [predictPart, computedClass];
            missDataIdx = [missDataIdx, missIndex];
            missDataSylNum = [missDataSylNum, data.stressNum(missIndex)];
            missDataSylPos = [missDataSylPos, data.stressPos(missIndex)];
            missDataComputedPos = [missDataComputedPos, missResult];
            fprintf('Syllable-wise Accuracy = %.2f %%\n', RecogAccuracySyl(i)*100);
            fprintf('Word-wise Accuracy = %.2f %%\n\n', RecogAccuracyWord(i)*100);
            meanAccuracySyl = mean(RecogAccuracySyl)*100;
            meanAccuracyWord = mean(RecogAccuracyWord)*100;
        end
    end
    
    missData = [missDataIdx; missDataSylNum; missDataSylPos; missDataComputedPos];  % for error analysis
    
    for j = 1:length(meanAccuracyWord)
        recognitionRate = [recognitionRate, meanAccuracyWord(j)];
    end
    
    Syl_2_RR = 100*sum(sylConf.gt2==sylConf.pos2) / length(sylConf.gt2);
    Syl_3_RR = 100*sum(sylConf.gt3==sylConf.pos3) / length(sylConf.gt3);
    Syl_4_RR = 100*sum(sylConf.gt4==sylConf.pos4) / length(sylConf.gt4);
    Syl_5_RR = 100*sum(sylConf.gt5==sylConf.pos5) / length(sylConf.gt5);
    Syl_6_RR = 100*sum(sylConf.gt6==sylConf.pos6) / length(sylConf.gt6);
    Syl_7_RR = 100*sum(sylConf.gt7==sylConf.pos7) / length(sylConf.gt7);
    Syl_8_RR = 100*sum(sylConf.gt8==sylConf.pos8) / length(sylConf.gt8);
    
    fprintf('\n Classifier = %s, Syllable-wise Accuracy = %.2f %% , Word-wise Accuracy = %.2f %%, %d-fold cross validation\n', trainOpt.classifier{classifierNum}, meanAccuracySyl, meanAccuracyWord, trainOpt.foldNum);
    fprintf('\n 2-Syllable Accuracy = %.2f %%\n', Syl_2_RR);
    fprintf('\n 3-Syllable Accuracy = %.2f %%\n', Syl_3_RR);
    fprintf('\n 4-Syllable Accuracy = %.2f %%\n', Syl_4_RR);
    fprintf('\n 5-Syllable Accuracy = %.2f %%\n', Syl_5_RR);
    fprintf('\n 6-Syllable Accuracy = %.2f %%\n', Syl_6_RR);
    fprintf('\n 7-Syllable Accuracy = %.2f %%\n', Syl_7_RR);
    fprintf('\n 8-Syllable Accuracy = %.2f %%\n', Syl_8_RR);
    
    
       %% ======  Confusion Table Plotting
    if confPlotOpt
        close all;
        
        confOpt = confMatPlot('defaultOpt');
        confOpt.className = {'Stressed', 'Unstressed'};
        confOpt.mode = 'both';
        confOpt.format = '8.2f';

        figure;
        gtPart(gtPart==0) = 2;
        predictPart(predictPart==0) = 2;
        confMat = confMatGet(gtPart, predictPart);
        confMatPlot(confMat, confOpt);
        title(meanAccuracySyl);
        saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_allSylConfMat.png']);

        confOpt = confMatPlot('defaultOpt');
        
        figure;
        confMat2 = confMatGet(allConf.gtPos, allConf.predictPos);
        confOpt.className = {'1th' ,'2nd', '3rd', '4th', '5th', '6th'};
        confMatPlot(confMat2, confOpt);
        title(meanAccuracyWord);
        saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_wordConfMat.png']);
        
        if ~isnan(sylConf.gt2)
            figure;
            confMat_syl2 = confMatGet(sylConf.gt2, sylConf.pos2);
            confOpt.className = {'1th' ,'2nd'};
            confMatPlot(confMat_syl2, confOpt);
            title('2-Syllable');
            saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_2SylConfMat.png']);
        end
        
        if ~isnan(sylConf.gt3)
            figure;
            confMat_syl3 = confMatGet(sylConf.gt3, sylConf.pos3);
            confOpt.className = {'1th' ,'2nd', '3rd'};
            confMatPlot(confMat_syl3, confOpt);
            title('3-Syllable');
            saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_3SylConfMat.png']);
        end
        
        if ~isnan(sylConf.gt4)
            figure;
            confMat_syl4 = confMatGet(sylConf.gt4, sylConf.pos4);
            confOpt.className = {'1th' ,'2nd', '3rd', '4th'};
            confMatPlot(confMat_syl4, confOpt);
            title('4-Syllable');
            saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_4SylConfMat.png']);
        end
        
        if ~isnan(sylConf.gt5)
            figure;
            confMat_syl5 = confMatGet(sylConf.gt5, sylConf.pos5);
            confOpt.className = {'1th' ,'2nd', '3rd', '4th', '5th'};
            confMatPlot(confMat_syl5, confOpt);
            title('5-Syllable');
            saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_5SylConfMat.png']);
        end
        
        if ~isnan(sylConf.gt6)
            figure;
            confMat_syl6 = confMatGet(sylConf.gt6, sylConf.pos6);
            confOpt.className = {'1th' ,'2nd', '3rd', '4th', '5th', '6th'};
            confMatPlot(confMat_syl6, confOpt);
            title('6-Syllable');
            saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_6SylConfMat.png']);
        end
        
        if ~isnan(sylConf.gt7)
            figure;
            confMat_syl7 = confMatGet(sylConf.gt7, sylConf.pos7);
            confOpt.className = {'1th' ,'2nd', '3rd', '4th', '5th', '6th', '7th'};
            confMatPlot(confMat_syl7, confOpt);
            title('7-Syllable');
            saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_7SylConfMat.png']);  
        end
        
        if ~isnan(sylConf.gt8)
            figure;
            confMat_syl8 = confMatGet(sylConf.gt8, sylConf.pos8);
            confOpt.className = {'1th' ,'2nd', '3rd', '4th', '5th', '6th', '7th', '8th'};
            confMatPlot(confMat_syl8, confOpt);
            title('8-Syllable');
            saveas(gcf, ['output/fig/' trainOpt.classifier{classifierNum} '_8SylConfMat.png']);  
        end
    end
    
                       
end

%% ====== Excel File Exporting
if xlsOpt
    xlswrite(['output/sylRR_' data.type], [Syl_2_RR, Syl_3_RR, Syl_4_RR, Syl_5_RR, Syl_6_RR, Syl_7_RR, Syl_8_RR]);
    xlswrite(['output/classifierRR_' data.type], recognitionRate);
end
            
                    
%% ====== Error Analysis
if errorAnaly
   save  mat/missData.mat missData;
end