import { Readable, ReadableOptions, Transform, TransformCallback } from "stream"
import { Worksheet, stream, Column, Workbook, Style }  from "exceljs"
import { Multer} from "multer"

function setAdditionalKeyInstance(target:any, option:any):any
{
	if(!target) return option;
	else
	{
		let keys = Object.keys(target);
		let optionKeys = Object.keys(option);
		if(!keys)
		{
			return option;
		}
		if(!optionKeys)
		{
			return target;
		}

		for(let keyIdx = 0; keyIdx < keys.length; keyIdx++)
		{
			let key = keys[keyIdx];
			target[key] = !option[key] ? target[key] : option[key];
		}

		for(let keyIdx = 0; keyIdx < optionKeys.length; keyIdx++)
		{
			let key = optionKeys[keyIdx];
			target[key] = option[key];
		}

		return target;
	}

}

export interface ExcelStreamOptions{
	// zip: Partial<ArchiverZipOptions>;
	stream?: import('stream').Stream,
					// filename: string; //If stream not specified, this field specifies the path to a file to write the XLSX workbook to.
	useSharedStrings?: boolean, //Specifies whether to use shared strings in the workbook. Default is false
	useStyles?: boolean
}

export interface ExcelWorkSheetInfo{
	name:string,
	columns:Column[]
}

export interface ExcelWorkBookOptions{
	category?: string;
    company?: string;
	creator?: string;
    description?: string;
    keywords?: string;
	lastModifiedBy?: string;
	created?: Date;
    manager?: string;
	modified?: Date;
	lastPrinted?: Date;
	// properties?: WorkbookProperties;
	subject?: string;
    title?: string;
}

export interface ExcelDataInfo{
	sheetName:string,
	row:any,
}

export interface ExcelParseInfo{
	colName:string,
	targetIndex:number | Array<number>
	convertFunction?:Function
}

export interface ExcelParseSheetInfo{
	/**
	 * row start index start from 1
	 */
	rowStartIdx?:number,
	/**
	 * col start index start from 1
	 */
	colStartIdx?:number,
	/**
	 * row end index excel row number
	 */
	rowEndIdx?:number,
	/**
	 * col end index excel row number
	 */
	colEndIdx?:number,
	/**
	 * additional parse options
	 */
	parseInfo?:Array<ExcelParseInfo>
}

/**
 * excel 객체 생성 및 관리
 */
export class ExcelExport{
	public workbook:Workbook;
	/**
	 * excel 객체 map
	 */
	public worksheetArr:Map<string, Worksheet> = new Map();
	
	/**
	 * excel 객체 생성 및 관리
	 */
	constructor(public fileName:string, public workbookOptions:ExcelWorkBookOptions, public sheetInfos:any[], public defaultWorksheetOption:any)
	{
		this.workbook = new Workbook();

		if(workbookOptions)
		{
			this.workbook.category = workbookOptions.category as string
			this.workbook.company = workbookOptions.company as string
			this.workbook.creator = workbookOptions.creator as string
			this.workbook.description = workbookOptions.description as string
			this.workbook.keywords = workbookOptions.keywords as string
			this.workbook.lastModifiedBy = workbookOptions.lastModifiedBy as string
			this.workbook.created = workbookOptions.created as Date
			this.workbook.manager = workbookOptions.manager as string
			this.workbook.modified = workbookOptions.modified as Date
			this.workbook.lastPrinted = workbookOptions.lastPrinted as Date
			//this.workbook.properties = workbookOptions.properties
			this.workbook.subject = workbookOptions.subject as string
			this.workbook.title = workbookOptions.title as string;
		}

		for(let idx=0; idx < sheetInfos.length; idx++)
		{
			let sheetInfo = sheetInfos[idx];
			let worksheetVal = this.workbook.addWorksheet(sheetInfo.name, !defaultWorksheetOption ? {	views: [{showGridLines: true}],properties:{defaultRowHeight:13.2}	}: defaultWorksheetOption);

			worksheetVal.columns = sheetInfo.columns

			let columnLength = !sheetInfo.columns ? 0 : sheetInfo.columns.length;

			worksheetVal.columns = sheetInfo.columns;

			let mergeDistance = 0;

			if(sheetInfo.headers)
			{
				let headers = sheetInfo.headers;
				for(let infoIdx = 0; infoIdx < headers.length ; infoIdx++)
				{
					let header:any = headers[infoIdx];
					let targetRow = infoIdx + 1 + mergeDistance;

					if(typeof header !== "string")
					{
						let targetHeaderRow = worksheetVal.getRow(targetRow);
						if(header.merge)
						{
							if(header.merge.cellStart && header.merge.cellEnd)
							{
								worksheetVal.mergeCells(header.merge.cellStart, header.merge.cellEnd);

								let distanceReg = new RegExp('[a-zA-Z]', 'g')
								let distanceFrom = 0;
								let distanceEnd = 0;
								try
								{
									distanceFrom = Number(header.merge.cellStart.replace(distanceReg, ''));
									distanceEnd = Number(header.merge.cellEnd.replace(distanceReg, ''));
								}
								catch(e)
								{

								}

								mergeDistance += (distanceFrom - distanceEnd);
							}
							else
							{
								worksheetVal.mergeCells(header.merge.rowStart, header.merge.colStart, header.merge.rowEnd, header.merge.colEnd);

								mergeDistance += (header.merge.rowEnd - header.merge.rowStart);

							}
						}

						if(typeof header.value === "string")
						{
							targetHeaderRow.getCell(1).value = header.value;
						}
						else if(Array.isArray(header.value))
						{
							for(let valIdx = 0; valIdx < header.value.length; valIdx++)
							{
								let targetValue = header.value[valIdx];
								if(typeof targetValue === "string")
								{
									targetHeaderRow.getCell(1).value = targetValue;
								}
								else if (targetValue.index)
								{
									targetHeaderRow.getCell(targetValue.index).value = targetValue.value;
								}
							}
						}

						targetHeaderRow.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
							cell.style = this.getDefaultCellStyle(0);
						});

						if(header.style)
						{
							let styleValue = header.style;
							if(Array.isArray(styleValue))
							{
								for(let styleIdx = 0; styleIdx < styleValue.length; styleIdx++)
								{
									let singleStyle = styleValue[styleIdx];
									// targetHeaderRow.getCell(singleStyle.index).style = singleStyle.style;
									if(!singleStyle.index)
									{

									}
									else
									{
										let getSingleCell = targetHeaderRow.getCell(singleStyle.index);
										getSingleCell.style = setAdditionalKeyInstance(getSingleCell.style, singleStyle.style)

									}
								}
							}
							else
							{
								targetHeaderRow.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
									// cell.style = styleValue as Partial<Style>;
									cell.style = setAdditionalKeyInstance(cell.style, styleValue as Partial<Style>)
								});
							}
						}
					}
					else
					{
						worksheetVal.mergeCells(targetRow, 1, targetRow,  columnLength);

						let defaultheaderRow = worksheetVal.getRow(targetRow)
						let targetCellDefault = defaultheaderRow.getCell(1);
						targetCellDefault.value = header;

						defaultheaderRow.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
							cell.style = this.getDefaultCellStyle(0);
						});
					}
				}

				if(sheetInfo.columns)
				{
					let colHeaderArr = [];
					for(let colHeaderIdx = 0; colHeaderIdx < sheetInfo.columns.length; colHeaderIdx++)
					{
						let colInfo = sheetInfo.columns[colHeaderIdx]
						colHeaderArr.push(!colInfo.header ? colInfo.key : colInfo.header);
					}

					let headerRow = worksheetVal.getRow(headers.length + 1 + mergeDistance);
					headerRow.values = colHeaderArr;

					headerRow.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
						cell.style = this.getDefaultCellStyle(1)
					});

				}
			}
			else
			{
				//no headers info setted
			}

			this.worksheetArr.set(sheetInfo.name, worksheetVal);
		}
	}

	/**
	 * cell default style 설정
	 */
	private getDefaultCellStyle(mode:number):Partial<Style>
	{
		switch(mode)
		{
			case 0: //header cell
				return {
					font:{size:10, name:'Malgun Gothic'},
					border:{
						top:{style:'thin'},
						left:{style:'thin'},
						bottom:{style:'thin'},
						right:{style:'thin'},
					},
					alignment:{vertical: 'middle', horizontal: 'center'}
				};
			case 1: //data cell
				return {
					alignment:{ vertical: 'middle', horizontal: 'center' },
					font:{size:10, name:'Malgun Gothic', 'bold': true},
					border:{
						top:{style:'thin'},
						left:{style:'thin'},
						bottom:{style:'thin'},
						right:{style:'thin'},
					},
					fill:{
						type:"pattern",
						pattern:"solid",
						// bgColor:{argb: 'C3C3C300'}
						// bgColor:{argb: 'A6A6A601'},
						fgColor:{argb:'FFA6A6A6'},
						// F08080
					}
				};
			default: return {};
		}

	}
	/**
	 * 생성된 excel sheet 라인 추가(단건)
	 *       {sheetName, row}
	 */
	public addRow(data:ExcelDataInfo)
	{
		this.worksheetArr.get(data.sheetName)?.addRow(data.row)
	}

	/**
	 * 생성된 excel sheet 라인 추가(여러건)
	 *       {sheetName, row}
	 */
	public addRows(datas:ExcelDataInfo[])
	{
		for(let idx=0; idx < datas.length; idx++)
		{
			let data = datas[idx];
			this.worksheetArr.get(data.sheetName)?.addRow(data.row)
		}
	}

	/**
	 * excel 객체 response로 export
	 */
	public async export(res:any):Promise<void>{
		
        res.status(200);
        res.setHeader('Content-disposition', `attachment; filename=${this.fileName}`);
        res.setHeader('Content-type', 'application/vnd.ms-excel');
		// this.workbook.xlsx.write(res);

		return this.workbook.xlsx.write(res).then(function () {
			res.status(200).end();
		  });
	}
}
/**
 * excel 출력 범위지정
 */
export interface ExcelExportMerge{
	cellStart?:string,
	cellEnd?:string,
	rowStart?:number,
	colStart?:number,
	rowEnd?:number,
	colEnd?:number,
}
/**
 * excel header 정보
 */
export interface ExcelHeaderValue{
	index:number,
	value:string
}

/**
 * excel header style 정보
 */
export interface ExcelHeaderStyleInfo{
	index:number,
	style:Partial<Style>
}

/**
 * excel export header 정보 설정
 */
export interface ExcelExportHeaderInfo{
	value?:Array<Partial<ExcelHeaderValue>> | string,
	merge?:ExcelExportMerge,
	style?:Partial<Style> | Array<Partial<ExcelHeaderStyleInfo>>,
}

/**
 * excel export 정보 설정
 */
export interface ExcelExportInfo{
	name?:string,
	headers?:Array<Partial<ExcelExportHeaderInfo> | string>,
	columns?:Array<Partial<Column>>,
	dataFunction?:Function
}

/**
 * stream input 을 받아 excel output stream으로 response에 전송
 */
export class ExcelExportTransform extends Transform{
    public workbook?:stream.xlsx.WorkbookWriter;
	// public worksheetArr:Map<string, Worksheet> = new Map();
	// public worksheetArr:Array<any> = [];
	public worksheet?:Worksheet;

	/**
	 * stream input 을 받아 excel output stream으로 response에 전송
	 *       ex)  
	 * 			result = query 결과 (executeStream을 사용해야함)
	 * 			result.pipe(
	 * 				new ExcelExportTransform(파일이름
                                            , 출력 stream(ex: response)
                                            , sheet의 style (ex: {useStyles:true} )
												//-> ExcelJs.Style 참조 
                                            , {   name: 시트명,
												  headers:[
													헤더 colums 설정
													ex)
													// {   
													//     merge:{rowStart:2, colStart:1, rowEnd:3, colEnd:7},
													//     value:[{index:1, value:"출력일시 : "}, {index:8, value:"아무거나2"} ],
													//     style:[{index:1, style:{
													//                     fill:{
													//                         type:"pattern",
													//                         pattern:"solid",
													//                         fgColor:{argb:'FFA6A6A6'},
													//                     }
													//                 }
													//             },
													//             {index:8, style:{
													//                 fill:{
													//                     type:"pattern",
													//                     pattern:"solid",
													//                     fgColor:{argb:'FFFFA6A6'},
													//                 }
													//             }
													//         }
													//     ]
													// } 
												  ],
                                                  columns:[
													columns 설정
													ex)
													//{key:"BIN_DISP_CD", header:"BIN_NO"}
                                                  ]
                                                }
                    ));
	 */
	constructor(public fileName:string, res:any, public transformOption:ExcelStreamOptions, public sheetInfo:ExcelExportInfo){
        super({objectMode:true});
		// console.log("=================================================================== ExcelTransform ==============================================================")
		try
		{
			res.status(200);
			res.setHeader('Content-disposition', `attachment; filename=${fileName}.xls`);
			res.setHeader('Content-type', 'application/vnd.ms-excel');

			if(!transformOption) transformOption = {};
			if(!transformOption.stream) transformOption.stream = res;
			if(!transformOption.useStyles) transformOption.useStyles = true;

			this.workbook = new stream.xlsx.WorkbookWriter(transformOption);
			
			if(!sheetInfo) sheetInfo = {name:"sheet1"}
			if(!sheetInfo.name) sheetInfo.name = "sheet1"
			
			let worksheetVal:any = this.workbook.addWorksheet(	sheetInfo.name,
															{	views: [{showGridLines: false}], 
																properties:{defaultRowHeight:13.2}	}	);
			// worksheetVal.showGridLines = false

			let columnLength = !sheetInfo.columns ? 0 : sheetInfo.columns.length;

			worksheetVal.columns = sheetInfo.columns;

			let mergeDistance = 0;

			if(sheetInfo.headers)
			{
				let headers = sheetInfo.headers;
				for(let infoIdx = 0; infoIdx < headers.length ; infoIdx++)
				{
					let header:any = headers[infoIdx];
					let targetRow = infoIdx + 1 + mergeDistance;

					if(typeof header !== "string")
					{
						let targetHeaderRow = worksheetVal.getRow(targetRow);
						if(header.merge)
						{
							if(header.merge.cellStart && header.merge.cellEnd)
							{
								worksheetVal.mergeCells(header.merge.cellStart, header.merge.cellEnd);

								let distanceReg = new RegExp('[a-zA-Z]', 'g')
								let distanceFrom = 0;
								let distanceEnd = 0;
								try
								{
									distanceFrom = Number(header.merge.cellStart.replace(distanceReg, ''));
									distanceEnd = Number(header.merge.cellEnd.replace(distanceReg, ''));
								}
								catch(e)
								{

								}

								mergeDistance += (distanceFrom - distanceEnd);
							}
							else
							{
								worksheetVal.mergeCells(header.merge.rowStart, header.merge.colStart, header.merge.rowEnd, header.merge.colEnd);

								mergeDistance += (header.merge.rowEnd - header.merge.rowStart);

							}
						}
						
						if(typeof header.value === "string")
						{
							targetHeaderRow.getCell(1).value = header.value;
						}
						else if(Array.isArray(header.value))
						{
							for(let valIdx = 0; valIdx < header.value.length; valIdx++)
							{
								let targetValue = header.value[valIdx];
								if(typeof targetValue === "string")
								{
									targetHeaderRow.getCell(1).value = targetValue;
								}
								else if (targetValue.index)
								{
									targetHeaderRow.getCell(targetValue.index).value = targetValue.value;
								}
							}
						}

						targetHeaderRow.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
							cell.style = this.getDefaultCellStyle(0);
						});

						if(header.style)
						{
							let styleValue = header.style;
							if(Array.isArray(styleValue))
							{
								for(let styleIdx = 0; styleIdx < styleValue.length; styleIdx++)
								{
									let singleStyle = styleValue[styleIdx];
									// targetHeaderRow.getCell(singleStyle.index).style = singleStyle.style;
									if(!singleStyle.index)
									{
										
									}
									else
									{
										let getSingleCell = targetHeaderRow.getCell(singleStyle.index);
										getSingleCell.style = setAdditionalKeyInstance(getSingleCell.style, singleStyle.style)

									}
								}
							}
							else
							{
								targetHeaderRow.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
									// cell.style = styleValue as Partial<Style>;
									cell.style = setAdditionalKeyInstance(cell.style, styleValue as Partial<Style>)
								});
							}
						}
					}
					else
					{
						worksheetVal.mergeCells(targetRow, 1, targetRow,  columnLength);
						
						let defaultheaderRow = worksheetVal.getRow(targetRow)
						let targetCellDefault = defaultheaderRow.getCell(1);
						targetCellDefault.value = header;
						
						defaultheaderRow.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
							cell.style = this.getDefaultCellStyle(0);
						});
					}
				}

				if(sheetInfo.columns)
				{
					let colHeaderArr = [];
					for(let colHeaderIdx = 0; colHeaderIdx < sheetInfo.columns.length; colHeaderIdx++)
					{
						let colInfo = sheetInfo.columns[colHeaderIdx]
						colHeaderArr.push(!colInfo.header ? colInfo.key : colInfo.header);
					}
					
					let headerRow = worksheetVal.getRow(headers.length + 1 + mergeDistance);
					headerRow.values = colHeaderArr;

					headerRow.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
						cell.style = this.getDefaultCellStyle(1)
					});

				}
			}
			else
			{
				//no headers info setted
			}
			
			this.worksheet = worksheetVal;
		}
		catch(e)
		{
			console.log(e)
		}
        
    }

	/**
	 * cell default style 설정
	 */
	private getDefaultCellStyle(mode:number):Partial<Style>
	{
		switch(mode)
		{
			case 0: //header cell
				return {
					font:{size:10, name:'Malgun Gothic'},
					border:{
						top:{style:'thin'},
						left:{style:'thin'},
						bottom:{style:'thin'},
						right:{style:'thin'},
					},
					alignment:{vertical: 'middle', horizontal: 'center'}
				};
			case 1: //data cell
				return {
					alignment:{ vertical: 'middle', horizontal: 'center' },
					font:{size:10, name:'Malgun Gothic', 'bold': true},
					border:{
						top:{style:'thin'},
						left:{style:'thin'},
						bottom:{style:'thin'},
						right:{style:'thin'},
					},
					fill:{
						type:"pattern",
						pattern:"solid",
						// bgColor:{argb: 'C3C3C300'}
						// bgColor:{argb: 'A6A6A601'},
						fgColor:{argb:'FFA6A6A6'},
						// F08080
					}
				};
			default: return {};
		}

	}
        
	/**
	 * input stream 건당 수행
	 */
    _transform(data: any, encoding: BufferEncoding, callback: TransformCallback): void{
		// this.worksheetArr.get(data.sheetName).addRow(data.row).commit();
		// let sheet = this.worksheetArr[0];
		// let row = this.worksheetArr[0].addRow(data);
		let row:any = this.worksheet?.addRow(data);

		row.eachCell({ includeEmpty: true }, (cell:any, colNumber:any)=>{
			cell.style = {	alignment:{ vertical: 'middle', horizontal: 'center' },
							font:{
								name:'Malgun Gothic',
								size:10,
							},
							border:{
								top:{style:'thin'},
								left:{style:'thin'},
								bottom:{style:'thin'},
								right:{style:'thin'},
							},
							fill:{
								type: "pattern",
								pattern:'none'
							}
						};
			if(this.sheetInfo.dataFunction)
			{
				this.sheetInfo.dataFunction(this.worksheet, row, cell, colNumber);
			}
		})

		row.commit();
		// this.worksheetArr[0].addRow(data).commit();
		//this.push(data) // next pipe call
        callback();
    }

	/**
	 * stream end 시 수행
	 */
    _flush(done: TransformCallback): void{
        this.workbook?.commit(); // final commit
		done()
    }

}

/**
 * excel import 제공
 */
export class ExcelImport{
	public workbook:Workbook = new Workbook();
	public target?:Express.Multer.File | string;

	/**
	 * excel import 제공 class 생성
	 */
	constructor(target?:Express.Multer.File | string)
	{
		this.workbook = new Workbook();
		this.target = target;

	}

	/**
	 * 행 하나 parse
	 */
	private async parseRow(sheet:Worksheet, colStartIdx:number, rowStartIdx:number, colEndIdx:number, rowEndIdx:number, parseInfos?:Array<ExcelParseInfo>)
	{
		// console.log(":================================================== parseRow")
		return new Promise((resolve, reject) =>{
			try{
				let returnValue:any;

				returnValue = sheet.getSheetValues();
				
				// console.log("================================== raw data :")
				// console.log( returnValue)

				colStartIdx = !colStartIdx || colStartIdx < 1 ? 1 : colStartIdx;
				rowStartIdx = !rowStartIdx || rowStartIdx < 1 ? 1 : rowStartIdx;
				colEndIdx = !colEndIdx || colEndIdx < 1 || colStartIdx > colEndIdx ? sheet.columnCount + 1 : colEndIdx + 1;
				rowEndIdx = !rowEndIdx || rowEndIdx < 1 || rowStartIdx > rowEndIdx ? sheet.rowCount + 1 : rowEndIdx + 1;

				// console.log("================================== data parse info :")
				// console.log(" colStartIdx :" + colStartIdx)
				// console.log(" rowStartIdx :" + rowStartIdx)
				// console.log(" colEndIdx :" + colEndIdx)
				// console.log(" rowEndIdx :" + rowEndIdx)

				returnValue = returnValue.slice(rowStartIdx, rowEndIdx);

				// console.log("================================== row sliced")
				// console.log(returnValue)
				
				// returnValue = await returnValue.map(async (row:any) => await this.parseRowInner(colStartIdx, colEndIdx, row, parseInfos))

				returnValue = returnValue.map( (row:any) => {
					if(parseInfos)
					{
						let returnObj:any = {};
		
						for(let idx=0; idx < parseInfos.length; idx++)
						{
							let parseInfo = parseInfos[idx];
							let value:any;
							let convertFunction = parseInfo.convertFunction;
		
							if(typeof parseInfo.targetIndex  !== "number")
							{
								value = parseInfo.targetIndex.map((targetIdx) => !convertFunction ? row[targetIdx] : convertFunction(row[targetIdx], row, targetIdx))
							}
							else
							{
								value = !convertFunction ? row[parseInfo.targetIndex] : convertFunction(row[parseInfo.targetIndex], row, parseInfo.targetIndex )
							}
		
							returnObj[parseInfo.colName] = value;
						}
		
						return returnObj;
					}
					else
					{
						// console.log("================================== col sliced")
						// console.log(" colStartIdx :" + colStartIdx)
						// console.log(" rowStartIdx :" + rowStartIdx)
						// console.log(" colEndIdx :" + colEndIdx)
						// console.log(" rowEndIdx :" + rowEndIdx)
						// console.log(row.slice(colStartIdx, colEndIdx))

						let slicedRow = row.slice(colStartIdx, colEndIdx);
						let rowVal = slicedRow.map((val:any)=>{
							if(typeof val == "object")
							{
								let returnStr = "";
								let textArr = val.richText;
								for(let textIdx = 0; textIdx < textArr.length; textIdx++)
								{
									returnStr += textArr[textIdx].text;
								}

								return returnStr;
							}
							else return val
						})

						return rowVal;
					}
				})

				resolve(returnValue)
			}
			catch(error)
			{
				reject(error)
			}
		})
	}

	/**
	 * excel import 데이터 parsing
	 * 		 ex) 
	 * 			let testExcelImport = new ExcelImport(file);
        		let parseResult = await testExcelImport.parse(
						[{rowStartIdx:2, colStartIdx:2,}], //파싱 시작지점, 들고올 시트넘버 배열과 매칭됨
            			[0]	//들고올 시트 넘버 배열(index array)
            	);
	 */
	public async parse(parseInfo?:Array<ExcelParseSheetInfo>, sheetIdxArr?:Array<number>):Promise<Array<string | number> | Array<object>>{
		
		if(typeof this.target === "string")
		{
			await this.workbook.xlsx.readFile(this.target);
		}
		else if(this.target?.path)
		{
			await this.workbook.xlsx.readFile(this.target.path);
		}
		else if(this.target?.buffer)
		{
			await this.workbook.xlsx.read(Readable.from(this.target.buffer));
		}
		
		let returnArr:Array<any> = [];
		let sheets:Worksheet[] = this.workbook.worksheets;
		let targetSheetArr:Array<Worksheet> = [];

		if(sheetIdxArr && sheetIdxArr.length > 0)
		{
			for(let targetIdx = 0; targetIdx < sheetIdxArr.length; targetIdx++)
			{
				targetSheetArr.push(sheets[sheetIdxArr[targetIdx]])
			}
		}
		else
		{
			targetSheetArr = sheets;
		}

		if(!targetSheetArr)
		{
			throw new Error("Import Excel Error occured : no sheed readed")
		}
		else
		{
			try
			{
				for(let sheetIdx = 0; sheetIdx < targetSheetArr.length; sheetIdx++)
				{
					let sheet:Worksheet = targetSheetArr[sheetIdx];

					let parseInfoSingle:any;
					try
					{
						if(parseInfo)
						{
							parseInfoSingle = !parseInfo[sheetIdx] ? {} : parseInfo[sheetIdx];
						}
					}
					catch(e)
					{
						parseInfoSingle = {};
					}

					let colStartIdx = parseInfoSingle.colStartIdx;
					let rowStartIdx = parseInfoSingle.rowStartIdx;
					let colEndIdx = parseInfoSingle.colEndIdx;
					let rowEndIdx = parseInfoSingle.rowEndIdx;
					
					returnArr.push(await this.parseRow(sheet, colStartIdx, rowStartIdx, colEndIdx, rowEndIdx, parseInfoSingle.parseInfo));
				}
			}
			catch(err)
			{
				console.log(err)
				throw new Error("Import Excel Error occured : parse error")
			}
		}

		return Promise.resolve(returnArr);
	}
}