package com.bizofficer.apiweb.testdetail;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.TypedQuery;
import javax.sql.DataSource;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.crossstore.ChangeSetPersister.NotFoundException;
import org.springframework.stereotype.Service;

import com.bizofficer.hibernate.entity.MocktestManagement;
import com.bizofficer.hibernate.entity.MocktestQuestionAssociation;
import com.bizofficer.hibernate.entity.ModelTestManagement;
import com.bizofficer.hibernate.entity.PgprepTestDetails;
import com.bizofficer.hibernate.entity.PgprepTestSummary;
import com.bizofficer.hibernate.entity.QbAssessmentItem;
import com.bizofficer.hibernate.entity.QbGroupedItem;
import com.bizofficer.module.questioncd.QuestionMapperBeanCD;
import com.bizofficer.module.questioncd.XmlToJsonCD;
import com.bizofficer.util.module.BeanQuestion;
import com.bizofficer.util.module.MysqlTableNames;
import com.bizofficer.util.module.QuestionHtml;



@Service
public class ResultMockTestService{
	
	private static final Logger logger = Logger.getLogger(ResultMockTestService.class);
	
	@Autowired
	EntityManagerFactory entityManagerFactory;
	
	@Autowired
    DataSource appDataSource;
    Connection conn;
    PreparedStatement ps, psX;
    ResultSet rs, rsX;
	
	public List<?> doExecute(Object obj) throws NotFoundException{
		BeanTesting objBean = (BeanTesting) obj; 	
		List<TestingPageBean> dataList = new ArrayList<TestingPageBean>();
		
		try {
			
		
			List<QuestionNumbersBean> questionNumbersList = new ArrayList<QuestionNumbersBean>();
			List<SectionSetBean> sectionSetList = new ArrayList<SectionSetBean>();
			SectionSetBean sectionSetBeanObj = new SectionSetBean();
			List<QuestionSetBean> questionSetList = new ArrayList<QuestionSetBean>();
			
			Integer totalAllSectionTime = 0;
			int currentSectionOrder = 0;
			String answerStatus = null;
			
			if(objBean.getTestSession()==null) {
				return dataList;
			}
			
			EntityManager entityManager = entityManagerFactory.createEntityManager();
			entityManager.getTransaction().begin();
			
			TestingPageBean testingPageBeanObj = new TestingPageBean();
			
			int questionIndex = 0;

			logger.info("ResultMockTestService getTestSession: "+objBean.getTestSession());
			
			TypedQuery<PgprepTestSummary> queryTS = (TypedQuery<PgprepTestSummary>) entityManager.createQuery("from "+PgprepTestSummary.class.getName()+" where testSession=:testSession", PgprepTestSummary.class);
			queryTS.setParameter("testSession", objBean.getTestSession());			
			queryTS.setFirstResult(0);
			queryTS.setMaxResults(1);
			List<?> resultListTS = queryTS.getResultList();
			Iterator<?> iteratorTS = resultListTS.iterator();
			if(iteratorTS.hasNext()){
				PgprepTestSummary myObjTS = (PgprepTestSummary)iteratorTS.next();
				
				objBean.setTestId(myObjTS.getTestRootId());
				if(myObjTS.getAnswerDivision()!=null && myObjTS.getAnswerDivision().length()>0) {
					String[] answeredArr = myObjTS.getAnswerDivision().split("\\|");
					testingPageBeanObj.setCorrectCount(Integer.valueOf(answeredArr[0]));
					testingPageBeanObj.setIncorrectCount(Integer.valueOf(answeredArr[1]));
					testingPageBeanObj.setNotAnsweredCount(Integer.valueOf(answeredArr[2]));
				}
			}
			
			logger.info("ResultMockTestService TEST Id: "+objBean.getTestId());
			
			TypedQuery<MocktestManagement> queryMTM = (TypedQuery<MocktestManagement>) entityManager.createQuery("from "+MocktestManagement.class.getName()+" where mocktestGeneratedId="+objBean.getTestId(), MocktestManagement.class);
			queryMTM.setFirstResult(0);
			queryMTM.setMaxResults(1);
			List<?> resultListMTM = queryMTM.getResultList();
			Iterator<?> iteratorMTM = resultListMTM.iterator();
			if(iteratorMTM.hasNext()){
				MocktestManagement myObjMTM = (MocktestManagement)iteratorMTM.next();
                
				testingPageBeanObj.setTestId(myObjMTM.getMocktestGeneratedId());
				testingPageBeanObj.setTestType(3);
				testingPageBeanObj.setModelTestId(myObjMTM.getModelTestId());
				testingPageBeanObj.setTestName(myObjMTM.getMocktestGeneratedTitle());				
				testingPageBeanObj.setSectionLock("No_Lock");
				
				logger.info( "Mocktest Id: " +   myObjMTM.getMocktestId() );
				logger.info( "Mocktest Generated Title: " +   myObjMTM.getMocktestGeneratedTitle() );
				
				///this.getSectionArr(entityManager, 47);
				
				List<String> sectionList = new ArrayList<String>();
				Boolean sectionAllow = false;
				ModelTestManagement myObjMOTM = null;
				TypedQuery<ModelTestManagement> queryMOTM = (TypedQuery<ModelTestManagement>) entityManager.createQuery("from "+ModelTestManagement.class.getName()+" where modelTestId="+myObjMTM.getModelTestId(), ModelTestManagement.class);
				queryMOTM.setFirstResult(0);
				queryMOTM.setMaxResults(1);
				List<?> resultListMOTM = queryMOTM.getResultList();
				Iterator<?> iteratorMOTM = resultListMOTM.iterator();
				if(iteratorMOTM.hasNext()){
					myObjMOTM = (ModelTestManagement)iteratorMOTM.next();
					
					testingPageBeanObj.setTotalTime(myObjMOTM.getDuration());
					testingPageBeanObj.setRemainingTime(myObjMOTM.getDuration());
					
					if(myObjMOTM.getSectionAllow()!=null && myObjMOTM.getSectionAllow()==1) {
						sectionAllow = true;
						sectionList = this.getSectionArr(myObjMOTM.getModelTestId());
					}
				}
				
				TypedQuery<MocktestQuestionAssociation> queryMQA = (TypedQuery<MocktestQuestionAssociation>) entityManager.createQuery("from "+MocktestQuestionAssociation.class.getName()+" where mocktestGeneratedId="+objBean.getTestId(), MocktestQuestionAssociation.class);
				List<?> resultListMQA = queryMQA.getResultList();
				
				logger.info("MocktestQuestionAssociation resultListMQA Size: "+resultListMQA.size());
				
				Iterator<?> iteratorMQA = resultListMQA.iterator();				
				while(iteratorMQA.hasNext()){
					MocktestQuestionAssociation myObjMQA = (MocktestQuestionAssociation)iteratorMQA.next();

					logger.info("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
					logger.info("MocktestQuestionAssociation Assess Id: "+myObjMQA.getAssessId());
					logger.info("MocktestQuestionAssociation MockQuesAssoNo: "+myObjMQA.getMockQuesAssoNo());
					
					TypedQuery<QbAssessmentItem> queryASTM = (TypedQuery<QbAssessmentItem>) entityManager.createQuery("from "+QbAssessmentItem.class.getName()+" where assessId="+myObjMQA.getAssessId(), QbAssessmentItem.class);
					queryASTM.setFirstResult(0);
					queryASTM.setMaxResults(1);
					List<?> resultListASTM = queryASTM.getResultList();
					Iterator<?> iteratorASTM = resultListASTM.iterator();
					if(iteratorASTM.hasNext()){
						QbAssessmentItem myObjASTM = (QbAssessmentItem)iteratorASTM.next();
						
						logger.info("QbAssessmentItem Assess Id: "+myObjASTM.getAssessId());
						
						String topicId = null;
						/// FETCH TOPIC
//						TypedQuery<QbItems> queryQBI = (TypedQuery<QbItems>) entityManager.createQuery("from "+QbItems.class.getName()+" where itemId="+myObjMQA.getAssessId(), QbItems.class);
//						queryQBI.setFirstResult(0);
//						queryQBI.setMaxResults(1);
//						List<?> resultListQBI = queryQBI.getResultList();
//						Iterator<?> iteratorQBI = resultListQBI.iterator();
//						if(iteratorQBI.hasNext()){
//							QbItems myObjQBI = (QbItems)iteratorQBI.next();
//							topicId = myObjQBI.getQbId();
//						}

						conn = appDataSource.getConnection();
				        if(conn != null){
				        	String sqlA = "SELECT * FROM qb_items WHERE item_id=? LIMIT 1";
				        	PreparedStatement stmtA = conn.prepareStatement(sqlA);
				        	stmtA.setInt(1, myObjMQA.getAssessId());
				            logger.info(this.getClass().getName()+": " + stmtA);
				            ResultSet myObjQBI = stmtA.executeQuery();
				            if(myObjQBI.next()) {  
				            	topicId = myObjQBI.getString("qb_id");
				            }		
				            myObjQBI.close();
				            stmtA.close();
				        }  
				        conn.close();
						
						//*******************************************************************************
						//	COMMON DATA QUESTION TYPE
						//*******************************************************************************
						if( "Common Data".equals(myObjASTM.getAssessTitle()) || "Common Data (5)".equals(myObjASTM.getAssessTitle())  ) {

							QuestionMapperBeanCD questionObj = (QuestionMapperBeanCD) new XmlToJsonCD().parse(myObjASTM.getAssessText());
							
								TypedQuery<QbGroupedItem> queryGBGI = (TypedQuery<QbGroupedItem>) entityManager.createQuery("from "+QbGroupedItem.class.getName()+" where assessId="+myObjASTM.getAssessId(), QbGroupedItem.class);
								queryGBGI.setFirstResult(0);
								queryGBGI.setMaxResults(myObjMQA.getNoOfQuestion());
								List<?> resultListGBGI = queryGBGI.getResultList();
								Iterator<?> iteratorGBGI = resultListGBGI.iterator();
								while(iteratorGBGI.hasNext()){
									QbGroupedItem myObjGBGI = (QbGroupedItem)iteratorGBGI.next();
									///logger.info("Item ID >> " + myObjGBGI.getItemId()  );
									
									//*******************************************************************************
									//	QUESTION SET START
									//*******************************************************************************
									QuestionSetBean questionSetBeanObj = new QuestionSetBean();
									
									logger.info("QbGroupedItem Assess Id: "+myObjGBGI.getItemId()*10000);
									logger.info("QbGroupedItem Assess Title: "+myObjGBGI.getItemTitle());
									logger.info(" PASSING TO PARSER ");
									logger.info("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");						
									
									BeanQuestion bqObj = new BeanQuestion();
									bqObj.setQuestionId(myObjGBGI.getItemId()*10000);
									bqObj.setItemId(myObjGBGI.getItemId());
									bqObj.setQuestionDisplayId(String.valueOf(myObjGBGI.getDisplayId()));
									bqObj.setQuestionType(myObjGBGI.getItemTitle());
									bqObj.setQuestionTypeLabel(myObjGBGI.getItemTitle());
									bqObj.setQuestionBody(myObjGBGI.getItemText());
									bqObj.setCommonDataDescription(questionObj.getItem().getDescription());
									////bqObj.setCommonDataDescription("Consider an ionic solid that dissolves in water according");

									questionSetBeanObj = new QuestionHtml().getXmlParser(bqObj,true);									
									
									// Get Student Answered **********************************************
									answerStatus = null;
									TypedQuery<PgprepTestDetails> queryPGTD = (TypedQuery<PgprepTestDetails>) entityManager.createQuery("from "+PgprepTestDetails.class.getName()+" where testSession=:testSession and assessId=:assessId and itemId=:itemId", PgprepTestDetails.class);
									queryPGTD.setParameter("testSession", objBean.getTestSession());
									queryPGTD.setParameter("assessId", myObjGBGI.getItemId());
									queryPGTD.setParameter("itemId", myObjGBGI.getItemId()); 
									queryPGTD.setFirstResult(0);
									queryPGTD.setMaxResults(1);
									List<?> resultListPGTD = queryPGTD.getResultList();
									Iterator<?> iteratorPGTD = resultListPGTD.iterator();
									if(iteratorPGTD.hasNext()){
										PgprepTestDetails myObjPGTD = (PgprepTestDetails)iteratorPGTD.next();
										if(myObjPGTD.getAnswerGiven()!=null && myObjPGTD.getAnswerGiven().length()>0) {
											questionSetBeanObj.setStudentResponse(myObjPGTD.getAnswerGiven());
											answerStatus = myObjPGTD.getStatus();
										}
									}										
									questionSetBeanObj.setTopicId(topicId);
									
									//*******************************************************************************
									//	SECTION START
									//*******************************************************************************
									if(Boolean.TRUE.equals(sectionAllow) && sectionList!=null && sectionList.size()>0) {			
										String[] sectionArr = sectionList.get(questionIndex).split("#");
										if(sectionArr[0]!=null) {
											
											questionSetBeanObj.setSectionName(sectionArr[0]);
											questionSetBeanObj.setSectionOrder(Integer.valueOf(sectionArr[1]));
											questionSetBeanObj.setSectionTime(Integer.valueOf(sectionArr[2]));
											questionSetBeanObj.setCorrectAnswerMarks(Double.valueOf(sectionArr[3]));
											questionSetBeanObj.setIncorrectAnswerMarks(Double.valueOf(sectionArr[4]));
											questionSetBeanObj.setNotAnswerMarks(Double.valueOf(sectionArr[5]));
											questionSetBeanObj.setSectionId(Integer.valueOf(sectionArr[6]));
											
											if(sectionArr[2]!=null && Integer.valueOf(sectionArr[2])>0) {
												totalAllSectionTime += Integer.valueOf(sectionArr[2]);
											}
											
											
											logger.info("currentSectionOrder CD: "+currentSectionOrder);
											logger.info("sectionArr[1] CD: "+sectionArr[1]);
											
											if(currentSectionOrder<Integer.valueOf(sectionArr[1])) {
												sectionSetBeanObj = new SectionSetBean();
												sectionSetBeanObj.setSectionName(sectionArr[0]);
												
												if(sectionArr[2]!=null && Integer.valueOf(sectionArr[2])>0) {
													sectionSetBeanObj.setSectionTime(Integer.valueOf(sectionArr[2]));
												}
												
												questionNumbersList = new ArrayList<QuestionNumbersBean>();
												
												QuestionNumbersBean questionNumbersBeanObj = new QuestionNumbersBean();
												questionNumbersBeanObj.setQuestionIndex(questionIndex);
												questionNumbersBeanObj.setQuestionId(myObjGBGI.getItemId()*10000);
												questionNumbersBeanObj.setAnswerStatus(answerStatus);
												questionNumbersList.add(questionNumbersBeanObj);
												
												sectionSetBeanObj.setQuestionNumbers(questionNumbersList);
																					
											}else {
												QuestionNumbersBean questionNumbersBeanObj = new QuestionNumbersBean();
												questionNumbersBeanObj.setQuestionIndex(questionIndex);
												questionNumbersBeanObj.setQuestionId(myObjGBGI.getItemId()*10000);
												questionNumbersBeanObj.setAnswerStatus(answerStatus);
												questionNumbersList.add(questionNumbersBeanObj);
											}
											
											if(currentSectionOrder<Integer.valueOf(sectionArr[1])) {
												sectionSetList.add(sectionSetBeanObj);
												currentSectionOrder = Integer.valueOf(sectionArr[1]);
											}	
											
											
										}
									}else { /// if section allow is false
										
										questionSetBeanObj.setCorrectAnswerMarks(myObjMOTM.getMarksCorrectAns());
										questionSetBeanObj.setIncorrectAnswerMarks(myObjMOTM.getMarksIncorrectAns());
										questionSetBeanObj.setNotAnswerMarks(myObjMOTM.getMarksNotAns());
										
										QuestionNumbersBean questionNumbersBeanObj = new QuestionNumbersBean();
										questionNumbersBeanObj.setQuestionIndex(questionIndex);
										questionNumbersBeanObj.setQuestionId(myObjGBGI.getItemId()*10000);
										questionNumbersBeanObj.setAnswerStatus(answerStatus);
										questionNumbersList.add(questionNumbersBeanObj);
										
									}									
									
									
									//*******************************************************************************
									//	SECTION END
									//*******************************************************************************
									
									questionSetList.add(questionSetBeanObj);
									
									logger.info("questionIndex: "+questionIndex);
									
									questionIndex++;
									
									//*******************************************************************************
									//	QUESTION SET END
									//*******************************************************************************
									
								}
								
						//*******************************************************************************
						//	OTHER QUESTION TYPES THAN COMMON DATA
						//*******************************************************************************
						}else {							
							
							
							//*******************************************************************************
							//	QUESTION SET START
							//*******************************************************************************
							QuestionSetBean questionSetBeanObj = new QuestionSetBean();
							
							logger.info("QbGroupedItem Assess Id: "+myObjASTM.getAssessId());
							logger.info("QbGroupedItem Assess Title: "+myObjASTM.getAssessTitle());
							logger.info(" PASSING TO PARSER ");
							logger.info("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");						
							
							BeanQuestion bqObj = new BeanQuestion();
							bqObj.setQuestionId(myObjASTM.getAssessId());
							bqObj.setItemId(null);
							bqObj.setQuestionDisplayId(String.valueOf(myObjASTM.getDisplayId()));
							bqObj.setQuestionType(myObjASTM.getAssessTitle());
							bqObj.setQuestionTypeLabel(myObjASTM.getAssessTitle());
							bqObj.setQuestionBody(myObjASTM.getAssessText());
							bqObj.setCommonDataDescription(null);

							questionSetBeanObj = new QuestionHtml().getXmlParser(bqObj,true);
							
							// Get Student Answered **********************************************
							answerStatus = null;
							TypedQuery<PgprepTestDetails> queryPGTD = (TypedQuery<PgprepTestDetails>) entityManager.createQuery("from "+PgprepTestDetails.class.getName()+" where testSession=:testSession and assessId=:assessId", PgprepTestDetails.class);
							queryPGTD.setParameter("testSession", objBean.getTestSession());
							queryPGTD.setParameter("assessId", myObjASTM.getAssessId());
							queryPGTD.setFirstResult(0);
							queryPGTD.setMaxResults(1);
							List<?> resultListPGTD = queryPGTD.getResultList();
							Iterator<?> iteratorPGTD = resultListPGTD.iterator();
							if(iteratorPGTD.hasNext()){
								PgprepTestDetails myObjPGTD = (PgprepTestDetails)iteratorPGTD.next();
								if(myObjPGTD.getAnswerGiven()!=null && myObjPGTD.getAnswerGiven().length()>0) {
									questionSetBeanObj.setStudentResponse(myObjPGTD.getAnswerGiven());
									answerStatus = myObjPGTD.getStatus();
								}
							}
							
							questionSetBeanObj.setTopicId(topicId);

							//*******************************************************************************
							//	SECTION START
							//*******************************************************************************
							if(Boolean.TRUE.equals(sectionAllow) && sectionList!=null && sectionList.size()>0) {			
								String[] sectionArr = sectionList.get(questionIndex).split("#");
								if(sectionArr[0]!=null) {
									
									questionSetBeanObj.setSectionName(sectionArr[0]);
									questionSetBeanObj.setSectionOrder(Integer.valueOf(sectionArr[1]));
									questionSetBeanObj.setSectionTime(Integer.valueOf(sectionArr[2]));
									questionSetBeanObj.setCorrectAnswerMarks(Double.valueOf(sectionArr[3]));
									questionSetBeanObj.setIncorrectAnswerMarks(Double.valueOf(sectionArr[4]));
									questionSetBeanObj.setNotAnswerMarks(Double.valueOf(sectionArr[5]));
									questionSetBeanObj.setSectionId(Integer.valueOf(sectionArr[6]));
									
									if(sectionArr[2]!=null && Integer.valueOf(sectionArr[2])>0) {
										totalAllSectionTime += Integer.valueOf(sectionArr[2]);
									}									
									
									logger.info("currentSectionOrder: "+currentSectionOrder);
									logger.info("sectionArr[1]: "+sectionArr[1]);
									
									if(currentSectionOrder<Integer.valueOf(sectionArr[1])) {
										sectionSetBeanObj = new SectionSetBean();
										sectionSetBeanObj.setSectionName(sectionArr[0]);
										
										if(sectionArr[2]!=null && Integer.valueOf(sectionArr[2])>0) {
											sectionSetBeanObj.setSectionTime(Integer.valueOf(sectionArr[2]));
										}
										
										questionNumbersList = new ArrayList<QuestionNumbersBean>();
										
										QuestionNumbersBean questionNumbersBeanObj = new QuestionNumbersBean();
										questionNumbersBeanObj.setQuestionIndex(questionIndex);
										questionNumbersBeanObj.setQuestionId(myObjASTM.getAssessId());
										questionNumbersBeanObj.setAnswerStatus(answerStatus);
										questionNumbersList.add(questionNumbersBeanObj);
										
										sectionSetBeanObj.setQuestionNumbers(questionNumbersList);
																			
									}else {
										QuestionNumbersBean questionNumbersBeanObj = new QuestionNumbersBean();
										questionNumbersBeanObj.setQuestionIndex(questionIndex);
										questionNumbersBeanObj.setQuestionId(myObjASTM.getAssessId());
										questionNumbersBeanObj.setAnswerStatus(answerStatus);
										questionNumbersList.add(questionNumbersBeanObj);
									}
									
									if(currentSectionOrder<Integer.valueOf(sectionArr[1])) {
										sectionSetList.add(sectionSetBeanObj);
										currentSectionOrder = Integer.valueOf(sectionArr[1]);
									}	
									
									
								}
							}else { /// if section allow is false
								
								questionSetBeanObj.setCorrectAnswerMarks(myObjMOTM.getMarksCorrectAns());
								questionSetBeanObj.setIncorrectAnswerMarks(myObjMOTM.getMarksIncorrectAns());
								questionSetBeanObj.setNotAnswerMarks(myObjMOTM.getMarksNotAns());
								
								QuestionNumbersBean questionNumbersBeanObj = new QuestionNumbersBean();
								questionNumbersBeanObj.setQuestionIndex(questionIndex);
								questionNumbersBeanObj.setQuestionId(myObjASTM.getAssessId());
								questionNumbersBeanObj.setAnswerStatus(answerStatus);
								questionNumbersList.add(questionNumbersBeanObj);
								
							}
							
														
							//*******************************************************************************
							//	SECTION END
							//*******************************************************************************
							
							questionSetList.add(questionSetBeanObj);
							
							logger.info("questionIndex: "+questionIndex);
							
							questionIndex++;
							
							
							//*******************************************************************************
							//	QUESTION SET END
							//*******************************************************************************
						
							
						} /// ELSE CLOSE OF OTHER QUESITION TYPES
						
						
						
						
						
						
					}					
				}	
				
				
				if(Boolean.FALSE.equals(sectionAllow)) {
					sectionSetBeanObj.setQuestionNumbers(questionNumbersList);
					sectionSetList.add(sectionSetBeanObj);
				}
				
			} 
			
			if(totalAllSectionTime>0) {
				testingPageBeanObj.setTotalTime(totalAllSectionTime);
				testingPageBeanObj.setRemainingTime(totalAllSectionTime);
			}
			
			testingPageBeanObj.setSectionSet(sectionSetList);
			testingPageBeanObj.setQuestionSet(questionSetList);
			dataList.add(testingPageBeanObj);
			
			entityManager.getTransaction().commit();
			entityManager.close();
			
			logger.info("**************************************************************************");
			
			if(sectionSetList!=null) {
				logger.info("sectionSetList Count: "+sectionSetList.size());
			}
			
			if(questionSetList!=null) {
				logger.info("questionSetList Count: "+questionSetList.size());
			}
			
			logger.info("TEST RESULT CREATED");
			
			logger.info("**************************************************************************");
			
		}catch(Exception e) {
			e.getStackTrace();
		}
		
		////logger.info( "dataList >>> " +  dataList );
			
		return dataList;
	}

	
	private List<String> getSectionArr(Integer modelTestId) {
		List<String> sectionList = new ArrayList<String>();
		
		try {
		
				logger.info("SectionArr modelTestId >>> " + modelTestId  );
				
				conn = appDataSource.getConnection();
		        if(conn != null){
		        	String sqlA = "SELECT * FROM "+MysqlTableNames.getModelSectionManagement()+" WHERE model_id=? ";
		        	PreparedStatement stmtA = conn.prepareStatement(sqlA);
		        	stmtA.setInt(1, modelTestId);
		            logger.info(this.getClass().getName()+": " + stmtA);
		            ResultSet myObjMSM = stmtA.executeQuery();
		            int sectionOrder=0;
		            while (myObjMSM.next()) {  
			        	String sqlB = "SELECT * FROM "+MysqlTableNames.getSectionManagement()+" WHERE section_id=? order by section_id asc ";
			        	PreparedStatement stmtB = conn.prepareStatement(sqlB);
			        	stmtB.setInt(1, myObjMSM.getInt("section_id"));
			            logger.info(this.getClass().getName()+": " + stmtB);
			            ResultSet myObjSMM = stmtB.executeQuery();
			            while (myObjSMM.next()) {  
							sectionOrder+=1;
							for(int i=1; i<=myObjSMM.getInt("no_question"); i++) {
								sectionList.add(myObjSMM.getString("section_name")+"#"+sectionOrder+"#"+myObjSMM.getInt("section_time")+"#"+myObjSMM.getDouble("correct_marks")+"#"+myObjSMM.getDouble("incorrect_marks")+"#"+myObjSMM.getDouble("no_answer_marks")+"#"+myObjSMM.getInt("section_id"));
							}
							
						}
			            myObjSMM.close();
			            stmtB.close();
						
		            }	
		            myObjMSM.close();
		            stmtA.close();
				}
		        conn.close();
				
				logger.info( "sectionList Size >>> " +   sectionList.size() );
				int i = 0;
				for(String str : sectionList){
					logger.info( "str >>> " +i+ " == " +   str );
					i++;
			    }
				
				///logger.info( "sectionList >>> " +   sectionList.toString() );
				
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		return sectionList;
		
	}
	

//	private List<String> getSectionArr(EntityManager entityManager, Integer modelTestId) {
//		List<String> sectionList = new ArrayList<String>();
//		
//		logger.info("SectionArr modelTestId >>> " + modelTestId  );
//		
//		TypedQuery<ModelSectionManagement> queryMSM = (TypedQuery<ModelSectionManagement>) entityManager.createQuery("from "+ModelSectionManagement.class.getName()+" where modelId="+modelTestId, ModelSectionManagement.class);
//		List<?> resultListMSM = queryMSM.getResultList();
//		Iterator<?> iteratorMSM = resultListMSM.iterator();
//		int sectionOrder=0;
//		while(iteratorMSM.hasNext()){
//			ModelSectionManagement myObjMSM = (ModelSectionManagement)iteratorMSM.next();
//			////logger.info(  "myObjMSM.getSectionId() >>> " + myObjMSM.getSectionId()  );
//				TypedQuery<SectionManagement> querySM = (TypedQuery<SectionManagement>) entityManager.createQuery("from "+SectionManagement.class.getName()+" where sectionId="+myObjMSM.getSectionId()+" order by sectionId asc ", SectionManagement.class);
//				List<?> resultListSMM = querySM.getResultList();
//				Iterator<?> iteratorSMM=resultListSMM.iterator();				
//				while(iteratorSMM.hasNext()){
//					SectionManagement myObjSMM = (SectionManagement)iteratorSMM.next();
//									
//					sectionOrder+=1;
//					for(int i=1; i<=myObjSMM.getNoQuestion(); i++) {
//						sectionList.add(myObjSMM.getSectionName()+"#"+sectionOrder+"#"+myObjSMM.getSectionTime()+"#"+myObjSMM.getCorrectMarks()+"#"+myObjSMM.getIncorrectMarks()+"#"+myObjSMM.getNoAnswerMarks()+"#"+myObjSMM.getSectionId());
//					}
//					
//				}	
//		}
//		
//		logger.info( "sectionList Size >>> " +   sectionList.size() );
//		int i = 0;
//		for(String str : sectionList){
//			logger.info( "str >>> " +i+ " == " +   str );
//			i++;
//	    }
//		
//		///logger.info( "sectionList >>> " +   sectionList.toString() );
//		
//		return sectionList;
//	}
	
	
	
	
	
}