/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

package com.nokia.s60tools.swmtanalyser.model;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import org.apache.poi.hssf.usermodel.HSSFCell;

import org.apache.poi.hssf.usermodel.HSSFCellStyle;

import org.apache.poi.hssf.usermodel.HSSFFont;

import org.apache.poi.hssf.usermodel.HSSFRichTextString;

import org.apache.poi.hssf.usermodel.HSSFRow;

import org.apache.poi.hssf.usermodel.HSSFSheet;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import org.apache.poi.hssf.util.HSSFColor;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.swt.widgets.Display;

import com.nokia.s60tools.swmtanalyser.data.ChunksData;

import com.nokia.s60tools.swmtanalyser.data.CycleData;

import com.nokia.s60tools.swmtanalyser.data.DiskOverview;

import com.nokia.s60tools.swmtanalyser.data.GlobalDataChunks;

import com.nokia.s60tools.swmtanalyser.data.OverviewData;

import com.nokia.s60tools.swmtanalyser.data.ParsedData;

import com.nokia.s60tools.swmtanalyser.data.SystemData;

import com.nokia.s60tools.swmtanalyser.data.ThreadData;

import com.nokia.s60tools.swmtanalyser.data.WindowGroupEventData;

import com.nokia.s60tools.util.debug.DbgUtility;

/**

 * Creates Excel when log files exported. 

 *

 */

public class ExcelCreator {

	private String fileName;

	private FileOutputStream out;

	private HSSFWorkbook wb;

	private OverviewData ovData;

	private ArrayList<Integer> constants = new ArrayList<Integer>();

	private Map<String, HSSFCellStyle> styles;

	private ParsedData logData; 

	private Map<String, ArrayList<ThreadData>> heapData = new HashMap<String, ArrayList<ThreadData>> ();

	private Map<String, ArrayList<GlobalDataChunks>> glodData = new HashMap<String, ArrayList<GlobalDataChunks>> ();

	private Map<String, ArrayList<ChunksData>> chunkData = new HashMap<String, ArrayList<ChunksData>> ();

	private Map<String, ThreadData> deltaData = new HashMap<String, ThreadData> ();

	private Map<String, String> glodDeltaData = new HashMap<String, String> ();

	private Map<String, String> chunkDeltaData = new HashMap<String, String> ();

	private ArrayList<String> heapThreads;

	private ArrayList<String> glodChunks;

	private ArrayList<String> nonHeapChunks;

	private long totalHeapSizeChange =0;

	private long totalFreeCellChange =0;

	private long totalAllocCellChange =0;

	private long totalFreeSpaceChange =0;

	private long totalAllocSpaceChange =0;

	private long totalSlackSpaceChange =0;

	private long totalFilesChange =0;

	private long totalHandlesChange =0;

	private int j = 0;

	private static final String NOT_AVAILABLE = "N/A";

 	/**

 	 * Construction

 	 * @param fileName

 	 */

 	public ExcelCreator(String fileName) {

 		//create a new workbook

 		wb = new HSSFWorkbook();

 		this.fileName = fileName;

 	}

 	/**

 	 * Set overview data

 	 * @param ovdata

 	 */

 	public void setOverviewPageInput(OverviewData ovdata)

 	{

 		this.ovData = ovdata;

 	}

 	/**

 	 * Set all the parsed data of log files.

 	 * @param cyclesData

 	 */

 	public void setInputCyclesData(ParsedData cyclesData)

 	{

 		this.logData = cyclesData;

 	}

 	/**

 	 * The cycle numbers to be skipped when there are more than 254 cycles.

 	 * @param constants

 	 */

 	public void setSkipFileConstant(ArrayList<Integer> constants)

 	{

 		this.constants = constants;

 	}

 	private boolean updateMonitor(IProgressMonitor monitor, String message)

 	{

 		if(monitor!=null)

 			monitor.subTask(message);

 		if(monitor.isCanceled())

 		{

 			monitor.done();

 			try {

				out.close();

			} catch (IOException e) {

				e.printStackTrace();

			}

 			return false;

 		}

 		return true;

 	}

 	/**

 	 * Create a excel document

 	 * @param monitor

 	 * @return <code>true</code> if document was created successfully <code>false</code> otherwise.

 	 */

 	public boolean createExcel(IProgressMonitor monitor)

 	{

 		File file = new File(fileName);

 		if(file.exists() && !file.delete()){

 			Runnable p = new Runnable(){

				public void run() {

					MessageDialog.openError(Display.getCurrent().getActiveShell(), "SWMT Analyser", fileName + "file already exists and could not be deleted.\nPlease close it if open and try again.");

				}					

			};

			Display.getDefault().asyncExec(p);

			return false;

 		}

 		try {

			out = new FileOutputStream(fileName); 

		} catch (FileNotFoundException e) {

			Runnable p = new Runnable(){

				public void run() {

					MessageDialog.openError(Display.getCurrent().getActiveShell(), "SWMT Analyser", "Error in creating file " + fileName);

				}

			};

			Display.getDefault().asyncExec(p);

			return false;

		}

		styles = createStyles(wb);

		SWMTLogReaderUtils utilsObj = new SWMTLogReaderUtils();

		readGlobalDataFromAllCycles(glodData, logData);

		getFieldDifferencesForAllGlodChunks(glodDeltaData, logData);

		readChunkDataFromAllCycles(chunkData, logData);

		getFieldDifferencesForAllChunks(chunkDeltaData, logData);

		readHeapDataFromAllCycles(heapData, logData);

 		getFieldDifferencesForAllThreads(deltaData, logData);

		heapThreads = utilsObj.getAllHeapThreads(logData);

		Collections.sort(heapThreads);

 		if(!updateMonitor(monitor, "Creating overview sheet..."))

 			return false;

 		createOverViewTab();

		if(!updateMonitor(monitor, "Creating disk memory sheet..."))

			return false;			

 		createDiskVariationSheet();

		if(!updateMonitor(monitor, "Creating global chunks sheet..."))

 			return false;

 		createGlobalChunksSheet();

		if(!updateMonitor(monitor, "Creating non heap chunks sheet..."))

			return false;

		createNonHeapChunkSheet();

		if(!updateMonitor(monitor, "Creating heap size sheet..."))

			return false;

		createHeapSizeTab();

		if(!updateMonitor(monitor, "Creating heap allocated space sheet..."))

			return false;

		createHeapAllocSpaceTab();

		if(!updateMonitor(monitor, "Creating heap free space sheet..."))

			return false;

		createHeapFreeSpaceTab();

		if(!updateMonitor(monitor, "Creating allocated cells sheet..."))

			return false;

		createAllocatedCellsTab();

		if(!updateMonitor(monitor, "Creating free cells sheet..."))

			return false;

		createFreeCellsTab();

		if(!updateMonitor(monitor, "Creating free slack sheet..."))

			return false;

		createFreeSlackTab();

		if(!updateMonitor(monitor, "Creating largest allocated cells sheet..."))

			return false;

		createLargestAllocSizeTab();

		if(!updateMonitor(monitor, "Creating largest free size sheet..."))

			return false;

		createLargestFreeSizeTab();

		if(!updateMonitor(monitor, "Creating window groups sheet..."))

			return false;

		createWindowGroupSheet();

 		// write the workbook to the output stream

		// close our file (don't blow out our file handles

		try {

			wb.write(out);

			out.close();

		} catch (IOException err) {

			err.printStackTrace();

			try {

				out.close();

			} catch (IOException e) {

				e.printStackTrace();

			}

 			return false;

		}

 		return true;

 	}

	private boolean createOverViewTab()

	{

		//create a new sheet

		HSSFSheet sheet = wb.createSheet();

		// declare a row object reference

		HSSFRow row = null;

		// declare a cell object reference

		HSSFCell cell = null;

		//set the sheet name in Unicode

		wb.setSheetName(0, "Overview");

		row=sheet.createRow(0);

		//r.setHeight((short)500);

		cell= row.createCell(0);

		cell.setCellStyle(styles.get("header"));

		cell.setCellValue(new HSSFRichTextString("Overview"));

		row=sheet.createRow(1);

		cell=row.createCell(0);

		cell.setCellValue(new HSSFRichTextString("Number of Cycles"));

		cell=row.createCell(1);

		cell.setCellStyle(styles.get("cell_number"));

		CycleData firstCycle = logData.getLogData()[0];

		if(ovData.noOfcycles == 1)

			cell.setCellValue(new HSSFRichTextString(ovData.noOfcycles + " (" + firstCycle.getCycleNumber() + ")"));

		else

			cell.setCellValue(ovData.noOfcycles);

		row=sheet.createRow(2);

		cell=row.createCell(0);

		cell.setCellValue(new HSSFRichTextString("Number of Cycles Truncated"));

		cell=row.createCell(1);

		cell.setCellValue(constants.size());

		row=sheet.createRow(3);

		cell = row.createCell(0);

		cell.setCellValue(new HSSFRichTextString("Time Period"));

		HSSFCell timePeriod = row.createCell(1);

		row=sheet.createRow(4);

		cell=row.createCell(0);

		cell.setCellValue(new HSSFRichTextString("Time Duration"));

		cell=row.createCell(1);

		cell.setCellValue(new HSSFRichTextString(ovData.duration + " sec(" + ovData.durationString + ")"));

		row=sheet.createRow(5);

		cell=row.createCell(0);

		cell.setCellValue(new HSSFRichTextString("ROM Checksum"));

		cell=row.createCell(1);

		cell.setCellValue(new HSSFRichTextString(firstCycle.getRomCheckSum()));

		row=sheet.createRow(6);

		cell=row.createCell(0);

		cell.setCellValue(new HSSFRichTextString("ROM Version"));

		cell=row.createCell(1);

		cell.setCellValue(new HSSFRichTextString(firstCycle.getRomVersion()));

		sheet.createRow(7);

		sheet.createRow(8);

		sheet.createRow(9);

		row = sheet.createRow(10);

		cell = row.createCell(0);

		cell.setCellStyle(styles.get("header2"));

		cell.setCellValue(new HSSFRichTextString(""));

		cell = row.createCell(1);

		cell.setCellStyle(styles.get("header2"));

		cell.setCellValue(new HSSFRichTextString("Delta"));

		HSSFRow totalHeapSizeRow = sheet.createRow(11);

		cell = totalHeapSizeRow.createCell(0);

		cell.setCellStyle(styles.get("cell_bold"));

		cell.setCellValue(new HSSFRichTextString("Heap Size"));

		HSSFRow freeCellRow = sheet.createRow(12);

		cell = freeCellRow.createCell(0);

		cell.setCellStyle(styles.get("cell_bold"));

		cell.setCellValue(new HSSFRichTextString("Free Cell count"));

		HSSFRow alloCellRow = sheet.createRow(13);

		cell = alloCellRow.createCell(0);

		cell.setCellStyle(styles.get("cell_bold"));

		cell.setCellValue(new HSSFRichTextString("Allocated Cell count"));

		HSSFRow freeSpaceRow = sheet.createRow(14);

		cell = freeSpaceRow.createCell(0);

		cell.setCellStyle(styles.get("cell_bold"));

		cell.setCellValue(new HSSFRichTextString("Free space"));

		HSSFRow allocSpaceRow = sheet.createRow(15);

		cell = allocSpaceRow.createCell(0);

		cell.setCellStyle(styles.get("cell_bold"));

		cell.setCellValue(new HSSFRichTextString("Allocated space"));

		HSSFRow slackSpaceRow = sheet.createRow(16);

		cell = slackSpaceRow.createCell(0);

		cell.setCellStyle(styles.get("cell_bold"));

		cell.setCellValue(new HSSFRichTextString("Slack space"));

		HSSFRow filesRow = sheet.createRow(17);

		cell = filesRow.createCell(0);

		cell.setCellStyle(styles.get("cell_bold"));

		cell.setCellValue(new HSSFRichTextString("Total files"));

		HSSFRow psHandlesRow = sheet.createRow(18);

		cell = psHandlesRow.createCell(0);

		cell.setCellStyle(styles.get("cell_bold"));

		cell.setCellValue(new HSSFRichTextString("Total P&S Handles"));

		sheet.createRow(19);

		sheet.createRow(20);

		sheet.createRow(21);

		sheet.createRow(22);

		row = sheet.createRow(23);

		createOverviewFields(row);

		createDataInOverView(sheet, 24);

		cell = totalHeapSizeRow.createCell(1);

		cell.setCellStyle(styles.get("blue_font"));

		cell.setCellValue(totalHeapSizeChange);

		cell = freeCellRow.createCell(1);

		cell.setCellStyle(styles.get("blue_font"));

		cell.setCellValue(totalFreeCellChange);

		cell = alloCellRow.createCell(1);

		cell.setCellStyle(styles.get("blue_font"));

		cell.setCellValue(totalAllocCellChange);

		cell = freeSpaceRow.createCell(1);

		cell.setCellStyle(styles.get("blue_font"));

		cell.setCellValue(totalFreeSpaceChange);

		cell = allocSpaceRow.createCell(1);

		cell.setCellStyle(styles.get("blue_font"));

		cell.setCellValue(totalAllocSpaceChange);

		cell = slackSpaceRow.createCell(1);

		cell.setCellStyle(styles.get("blue_font"));

		cell.setCellValue(totalSlackSpaceChange);

		cell = filesRow.createCell(1);

		cell.setCellStyle(styles.get("blue_font"));

		cell.setCellValue(totalFilesChange);

		cell = psHandlesRow.createCell(1);

		cell.setCellStyle(styles.get("blue_font"));

		cell.setCellValue(totalHandlesChange);

		sheet.autoSizeColumn((short)0);

		sheet.autoSizeColumn((short)1);

		sheet.autoSizeColumn((short)2);

		sheet.autoSizeColumn((short)3);

		sheet.autoSizeColumn((short)4);

		sheet.autoSizeColumn((short)5);

		sheet.autoSizeColumn((short)6);

		sheet.autoSizeColumn((short)7);

		sheet.autoSizeColumn((short)8);

		sheet.autoSizeColumn((short)9);

		sheet.autoSizeColumn((short)10);

		sheet.autoSizeColumn((short)11);

		if(ovData.noOfcycles > 1)

			timePeriod.setCellValue(new HSSFRichTextString(ovData.fromTime + " to " + ovData.toTime));

		else

			timePeriod.setCellValue(new HSSFRichTextString(ovData.fromTime));

		return true;

	}

	/**

	 * This method creates the sheet for RAM and DISK Memory data.

	 * It shows the variation of RAM and Disk Memory in each cycle.

	 *

	 */

	private void createDiskVariationSheet() {

		//create a new sheet

		HSSFSheet sheet = wb.createSheet();

		// declare a row object reference

		HSSFRow row = null;

		HSSFRow description = null;

		// declare a cell object reference

		HSSFCell cell = null;

		//set the sheet name in Unicode

		wb.setSheetName(1, "RAM and Disk Memory");

		row = sheet.createRow(0);

		//r.setHeight((short)500);

		cell = row.createCell(0);

		cell.setCellStyle(styles.get("header"));

		cell.setCellValue(new HSSFRichTextString("RAM and Disk Memory"));

		description = sheet.createRow(1);

		//creates an empty row

		row = sheet.createRow(2);

		row = sheet.createRow(3);

    	cell = row.createCell(0);

		cell.setCellStyle(styles.get("header2"));

		cell.setCellValue(new HSSFRichTextString(""));

		addCycleIntervals(row);

		cell = row.createCell((int)(row.getLastCellNum()));

		cell.setCellStyle(styles.get("header2"));

		cell.setCellValue(new HSSFRichTextString("Delta"));

		SWMTLogReaderUtils utils = new SWMTLogReaderUtils();

		ArrayList<String> diskNames = utils.getAllDiskNames(logData);

		int rowNo = 4;

		row = sheet.createRow(rowNo);

		cell = row.createCell(0);

		cell.setCellStyle(styles.get("cell_normal"));

		cell.setCellValue(new HSSFRichTextString("RAM (Used)"));

		ArrayList<SystemData> systemData = utils.getSystemDataFromAllCycles(logData);

		long [] usedMemValues = new long[logData.getNumberOfCycles()];

		j=1;

		for(int i=0; i<logData.getNumberOfCycles(); i++)

		{

			long totalMem = systemData.get(i).getTotalMemory();

			long freeMem = systemData.get(i).getFreeMemory();

			if(totalMem == -1 || freeMem == -1){

				//cell.getCellStyle().setAlignment(HSSFCellStyle.ALIGN_CENTER);

				usedMemValues[i] = -1;

			}

			else{

				long usedMemory = totalMem - freeMem; 

				usedMemValues[i] = usedMemory;

			}

			if(constants.contains(i+1))

				continue;

			cell = row.createCell(j++);

			cell.setCellStyle(styles.get("cell_number"));

			cell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);

			if(usedMemValues[i] == -1)

				cell.setCellValue(new HSSFRichTextString(NOT_AVAILABLE));

			else

				cell.setCellValue(usedMemValues[i]);

			//cell.setCellValue(logData.get(i).getFreeMemory());

		}

		cell = row.createCell(logData.getNumberOfCycles()+1-constants.size());

		cell.setCellStyle(styles.get("cell_number"));

		long usedMemChange = utils.calculateDeltaForGivenSet(usedMemValues);

		cell.setCellValue(usedMemChange);