/**
 * 공통 그리드 그리기
 *
 * @param id  그리드 테이블 id
 * @param colModel 그리드 공통 컬럼명
 * @param data   데이터
 * @param option  옵션
 * 		@param 필수옵션   grid_class	: 생성할 그리드 명
 * 		@param 필수옵션   pagination_id: 페이지를 그릴 id
 * 		@param 필수옵션   width			: 그리드 넓이
 * 		@param 필수옵션   height		: 그리드 높이
 * 		@param 필수옵션   rowNum		: 한 페이지에 보여줄 그리드 row수
 * 		@param 필수옵션   gridPaging	: 페이징 유/무 (true/false)
 * 		@param 필수옵션   pagingType	: 보여줄 페이징 타입 (그리드자체페이징(grid_type), 페이징 분리(init_type))
 * 		@param 필수옵션   multiselect	: 멀티박스 유/무 (true/false)
 * 
 * 		@param 추가옵션   pageCallBack	: 라스트 재조회시 불리는 함수 (pagingType에 따라서 결정해서 옵션을 준다 - 그리드자체페이징(grid_type) : 주지않음, 페이징 분리(init_type): 줘야함 )
 * 		@param 추가옵션   sort_field	: 정렬필드명
 * 		@param 추가옵션   sort_option	: 정렬옵션 (asc/desc)
 * 		@param 추가옵션   totalCount 	: 데이터의 총 수
 * 		@param 추가옵션   page       	: 페이징처리를 위한 page

 * 
 * 		@param 그외 옵션  this._global_call		: 페이징 분리시 콜백함수로 돌아가기위한 변수
 * 		@param 그외 옵션  this._scroll       	: 페이징 유/무에따라 결정됨 	(gridPaging 유(true) -  this._scroll(false))
 * 											  					(gridPaging 무(false) -  this._scroll(true))
 */





// 현재 페이지 번호를 알수있는 변수
var currentPage;

// 현재 그리드 총 데이터 수
var gridTotalCount;


//그리드 생성시 실행
function EcoGrid(id, colModel, data, option) {
	
	//필수옵션
	this._gridid         	= id;
	this._grid_class		= option.grid_class; //생성된 그리드명
	this._pagination_id     = option.pagination_id;
	this._colModel       	= colModel;
	this._data       		= data;
	this._width         	= option.width || null;
	this._height        	= option.height || 400;
	this._rowNum 			= option.rowNum;
	this._pagingType		= option.pagingType || "grid_type"; //보여줄 페이징 타입 (그리드자체페이징(grid_type), 페이징 분리(init_type))
	
	this._gridPaging		= option.gridPaging || false; // 페이징 유(true) 무(false)
	
	if(option.multiselect == undefined)
	{
		this._multiselect		= true;
	}
	else
	{
		this._multiselect		= option.multiselect;
	}
	
	
	// 추가옵션
	this._pageCallBack 		= option.pageCallBack || undefined;			// 페이징과 정렬시 요청을 실행할 함수
	this._ondblClickRow 	= option.ondblClickRow || undefined;	// 그리드 row 더블 클릭시 실행할 함수
	this._onSelectRow 		= option.onSelectRow || undefined;	// 그리드 row 클릭시 실행할 함수
	this._onSelectAll 		= option.onSelectAll || undefined;	// 그리드 row 클릭시 실행할 함수
	this._onCellSelect		= option.onCellSelect || undefined;	// 그리드 row 클릭시 실행할 함수

	this._sort_field		= option.sort_field || '';
	this._sort_option		= option.sort_option || '';
	this._totalCount       	= option.totalCount || 0;
	this._page       		= option.page || 0;
	
	
	//2017.12.19 추가옵션 - 순번항목
	this._rownumbers			= option.rownumbers || false;
	if(option.rownumbers == true && option.rownumWidth == undefined)
		{
			this._rownumWidth		= 30;
		}
	else
		{
			this._rownumWidth			= option.rownumWidth;
		}
	
	
	//2018.01.10 추가 - 정렬 후에도 상태별 색상 유지
	this._loadComplete		= option.loadComplete || undefined; 
	
	//그외옵션
	this._global_call;
	
	// 페이징 유무에따른 스크롤 처리
	if(this._gridPaging==true){
		this._scroll = false;   // 페이징 유(true) - 스크롤무(false)
	}else{
		this._scroll = true;
	}
	
	//2018.07.23 추가 - 그리드 드래그 정렬 
	this._grid_drag			= option.grid_drag || false;
	
	// 24.08.07 최연희 - 그리드 정렬 후 처리할 함수
	this._afterSort		= option.afterSort || undefined;
	
	// 그리드 타입에따른 그리드 선택 + 맨처음 생성시 빈 그리드 그리기
	this._gridTypePrint('',this);
	
}


/**
 * 실제 그리드를 그릴때 실행되는 함수
 * 
 * 		@param 추가옵션   data       	: 그리드를 그릴때 매핑할 데이터
 * 		@param 추가옵션   page       	: 페이지
 * 		@param 추가옵션   sort_field	: 정렬필드명
 * 		@param 추가옵션   sort_option	: 정렬옵션 (asc/desc)
 * 		@param 추가옵션   totalCount   	: 데이터의 총 수
 */

//실제 그리드 그리기 + 추가옵션 재정리 + 그리드 타입에따른 그리드 선택 
EcoGrid.prototype._gridTypePrint = function(data,option){
	// 추가옵션                              
	this._data       		= data;
	this._page       		= option.page || 0;
	this._sort_field		= option.sort_field || "";
	this._sort_option		= option.sort_option || "";
	
	//totalCount 옵션
	if(option.totalCount != undefined){
		this._totalCount  = option.totalCount;
	}else {
		if(data != undefined)
		{
			this._totalCount  = data.length ;
		}
		else
		{
			this._totalCount  = 0;
		}
	}
	
	
	
// 샘플페이지(SampleMain.jsp)에서 테스트 떄문에 재정의	--------------------------------------------------------------------------------------------	
	
	//gridPaging옵션 - 페이징 유무
	if(option.gridPaging != undefined)
	{
		this._gridPaging		= option.gridPaging; // 페이징 유(true) 무(false) 
	}else{
		this._gridPaging;
	}
	
	//pagingType옵션 - 페이징 유형
	if( option.pagingType != undefined)
	{
		this._pagingType		= option.pagingType; //보여줄 페이징 타입 (그리드자체페이징(grid_type), 페이징 분리(init_type))
	}else{
		this._pagingType;
	}
					
	if(this._gridPaging==true){
		this._scroll = false;   // 페이징 유(true) - 스크롤무(false)
	}else{
		this._scroll = true;
	}
	
	
// 샘플페이지(SampleMain.jsp)에서 테스트 떄문에 재정의	--------------------------------------------------------------------------------------------	
	
	
	
	
	
	//페이징 타입에따른 그리드 분리
	if(this._pagingType == "grid_type" || this._pagingType == undefined){
		//그리드 페이징
		this._gridPrint(this);
	}else{
		//페이징 분리
		this._gridPrintDivision(this._sort_field,this._sort_option, this); 
	}
	
	
	//$('.ui-jqgrid-bdiv').perfectScrollbar();
	
	
};

//페이징 분리
EcoGrid.prototype._gridPrintDivision = function(columnName,sortOrder, obj){
	
	
	 // 이미 jqGrid가 존재하면 파괴하고 새로 생성ㄴ
	   if(null != $(obj._gridid)[0] && $(obj._gridid)[0].grid ){
	        $.jgrid.gridUnload(obj._gridid);
	    }
	   
	$(obj._gridid).jqGrid({
        datatype: "local",
        data:obj._data,
        colModel: obj._colModel,
        width: obj._width,
        height: obj._height,
        rowNum: obj._rowNum,
        shrinkToFit:false,
        styleUI : 'Bootstrap',
        multiselect: obj._multiselect,
        scroll:obj._scroll,
        sortname: obj._sort_field,
        sortorder: obj._sort_option,
        gridComplete:obj._gridComplete(obj) , 
        onSortCol: function(columnName,sortindex,sortOrder){
        	obj._pageCallBack(1,columnName,sortOrder);
        }, 
        ondblClickRow: function(rowid,iRow,iCol,e){
        	if(null != obj._ondblClickRow && undefined != obj._ondblClickRow)
    		{
        		obj._ondblClickRow(obj.gridRowData(),rowid);
    		}
        },
        onSelectRow: function(rowid,iRow,iCol,e){
        	if(obj._multiselect == true){
        		var rowindexes = $(obj._gridid).jqGrid("getGridParam","selarrrow");
        		//20.01.30 - 선택한 row 개수가 나오는데 문제가 없게하기위해서 이름을 다르게 수정함.
        		//20.03.11 이현주 - gridprint에서 오류가 났는데 혹시몰라서 수정.
        		var obj_grid_clss = obj._grid_class.replace(/^ /gi,"");
        		$('#'+obj_grid_clss+'grid_select_cnt').text(rowindexes.length);
        	}
      
        	if(null != obj._onSelectRow && undefined != obj._onSelectRow)
    		{
        		
        		obj._onSelectRow(obj.gridRowData(),rowid);
    		}
        },
        onSelectAll: function(aRowids,status )
        {
        	if(obj._multiselect == true){
	    		var rowindexes = $(obj._gridid).jqGrid("getGridParam","selarrrow");
	    		$('#'+obj._grid_class+'grid_select_cnt').text(rowindexes.length);
        	}
        	
        	if(null != obj._onSelectAll && undefined != obj._onSelectAll)
    		{
        		obj._onSelectAll(obj.gridRowData());
    		}
        	else if(null != obj._onSelectRow && undefined != obj._onSelectRow)
    		{
        		obj._onSelectRow(obj.gridRowData());
    		}
        },
        onCellSelect : function(rowid,index,contents)
       {
    	   if(null != obj._onCellSelect && undefined != obj._onCellSelect)
   		{
    		  obj._onCellSelect(rowid,index,contents);
   		}
    	   
       }, // 2017.12.19 추가 순번항목
        rownumbers 	: obj._rownumbers,
    	rownumWidth	: obj._rownumWidth
      });
	
	//2018.07.23 추가 - 그리드 드래그 정렬 
	if(obj._grid_drag == true){
		
		$(obj._gridid).sortableRows();   
		$(obj._gridid).jqGrid('gridDnD');
	}
	
};

//그리드 페이징
EcoGrid.prototype._gridPrint = function(obj){
	 // 이미 jqGrid가 존재하면 파괴하고 새로 생성
	if(null != $(obj._gridid)[0] && $(obj._gridid)[0].grid ){
        $.jgrid.gridUnload(obj._gridid);
    }
	  
	$(obj._gridid).jqGrid({
        datatype: "local",
        data:obj._data,
        colModel: obj._colModel,
        width: obj._width,
        height: obj._height,
        rowNum: obj._rowNum,
        shrinkToFit:false,
        styleUI : 'Bootstrap',
        multiselect: obj._multiselect,
        scroll:obj._scroll ,
        sortname: obj._sort_field,
        sortorder: obj._sort_option,
        gridComplete:obj._gridComplete(obj),
        onSortCol: function(columnName,sortindex,sortOrder){ 
        	//헤더클릭시 실행
        	obj._sortCol(columnName,sortOrder,obj);
        	
        	// 정렬 후 실행
        	if(obj._afterSort) {
            	setTimeout(function() {
            		obj._afterSort(obj);
            	}, 0);
        	}
        },
        ondblClickRow: function(rowid,iRow,iCol,e){
        	if(null != obj._ondblClickRow && undefined != obj._ondblClickRow)
    		{
        		obj._ondblClickRow(obj.gridRowData(),rowid);
    		}
        },
        onSelectRow: function(rowid,iRow,iCol,e){
        	if(obj._multiselect == true){
        		var rowindexes = $(obj._gridid).jqGrid("getGridParam","selarrrow");
        		//20.03.11 이현주 수정 - gridclass 앞에 공백이 들어가서 인식을 못해서 수정 
        		var obj_grid_clss = obj._grid_class.replace(/^ /gi,"");
        		$('#'+obj_grid_clss+'grid_select_cnt').text(rowindexes.length);
        	}
        	
        	if(null != obj._onSelectRow && undefined != obj._onSelectRow)
    		{
        		obj._onSelectRow(obj.gridRowData(),rowid);
    		}
        },
        onSelectAll: function(aRowids,status )
        {
        	if(obj._multiselect == true){
        		var rowindexes = $(obj._gridid).jqGrid("getGridParam","selarrrow");
        		$('#'+obj._grid_class+'grid_select_cnt').text(rowindexes.length);
        	}
        	
        	if(null != obj._onSelectAll && undefined != obj._onSelectAll)
    		{
        		obj._onSelectAll(obj.gridRowData());
    		}
        	else if(null != obj._onSelectRow && undefined != obj._onSelectRow)
    		{
        		obj._onSelectRow(obj.gridRowData());
    		}
        },
        onCellSelect : function(rowid,index,contents,event)
        {
     	   if(null != obj._onCellSelect && undefined != obj._onCellSelect)
    		{
        		obj._onCellSelect(rowid,index,contents);
    		}
     	   
        }, // 2017.12.19 추가 순번항목
        rownumbers 	: obj._rownumbers,
    	rownumWidth	: obj._rownumWidth,
    	
    	//2018.01.10 추가 - 정렬 후에도 상태별 색 상유지
    	loadComplete : obj._loadComplete
      });
	
	
	//2018.07.23 추가 - 그리드 드래그 정렬 
	if(obj._grid_drag == true){
		
		$(obj._gridid).sortableRows();   
		$(obj._gridid).jqGrid('gridDnD');
	}
};

//그리드정렬
EcoGrid.prototype._sortCol = function(columnName,sortOrder,obj){
	this._page = 1; // 헤더클릭 정렬시 페이지를 1페이지로 이동을 위해
	$(obj._gridid).jqGrid('setGridParam', {  
	    page:1,
	    sortname: columnName,
        sortorder: sortOrder,
        gridComplete:this._gridComplete(this)// 그리드 페이징시 페이지 이동을 보여주는 div에 대한 이동을 보여주려 this._gridComplete을 실행
	}).trigger("reloadGrid");
	
};

//그리드가 그려진 후 페이징 유/무 선택
EcoGrid.prototype._gridComplete = function(obj){
	if(obj._gridPaging==true){ //페이징 유
		$(obj._pagination_id).show();
		obj._TotalRowInPagination(obj);
		obj._initPaging(obj);
		
	}else if(obj._gridPaging==false){ //페이징 무
		$(obj._pagination_id).hide();
		obj._TotalRowInPagination(obj);
	}
	
//	$('.ui-jqgrid-bdiv').perfectScrollbar();
	
};

//페이징 분리 그리기
EcoGrid.prototype._initPaging = function (obj){
	var	table_selector			= obj._gridid;
	var	pagination_selector 	= obj._pagination_id;
	var	page_range				= 10; // 한 화면에 보여질 페이지 갯수 
	var	callback               	= obj._pageCallBack ;
	var	total_data_num         	= obj._totalCount;
	var	cur_page               	= obj._page;
	var	rowNum                 	= obj._rowNum;

	
    // 현재 한 번에 보여주는 row 숫자
	var cur_row_limit = rowNum;

    // 전체 페이지 길이 
    var total_page_num = Math.ceil(total_data_num / cur_row_limit);
   
    // 페이지를 1~10, 11~20 하는 식으로 그룹으로 표현할 때 몇 번째 그룹인지 
    var cur_page_group = parseInt( (cur_page - 1) / page_range);
    
    
    // 이전 페이지 그룹의 첫 번째 시작 
    var prev_group_first_page = ( cur_page_group - 1 ) * page_range + 1;
    if(prev_group_first_page < 0) prev_group_first_page = 1;

    // 다음 페이지 그룹의 첫 번째 시작
    var next_group_first_page = ( cur_page_group + 1 ) * page_range + 1;
    if(next_group_first_page > total_page_num) next_group_first_page = total_page_num;
    
    this._global_call = callback;
    
    var pagination_html = "";
    var to_print_page = cur_page_group * page_range + 1;
    
    //페이지를 그려주는 부분
    while(  (page_range > 0) && (to_print_page <= total_page_num) ){
        if(to_print_page == cur_page){
            pagination_html += this._getSinglePaginationBold(to_print_page); 
        } else {
            pagination_html += this._getSinglePagination(to_print_page);
        }
        page_range--;
        to_print_page++;
        
    }
    

    //2018.02.13 강예슬 추가 - 이전/다음 버튼 제대로 수행되도록 수정
    // 페이지네이션 처음, 이전
    //pagination_html = this._getFirstPagination() + this._getPrevGroupPagination(prev_group_first_page) + pagination_html;
    pagination_html = this._getFirstPagination() + this._getPrevGroupPagination(cur_page) + pagination_html;

    // 페이지네이션 다음, 끝
    //pagination_html += this._getNextGroupPagination(next_group_first_page) + this._getLastPagination(total_data_num);
    pagination_html += this._getNextGroupPagination(cur_page,total_page_num) + this._getLastPagination(total_data_num);
    
    // 데이터가 없는경우는 페이징 버튼을 안보여준다.
    if(this._data == null || undefined == this._data || 0 > this._data.length)
	{
    	pagination_html = "";
	}

    // 페이지네이션 추가
    $(pagination_selector)
        .empty()
        .append(pagination_html);
    
    
};


//실제 페이지부분을 그려줌
EcoGrid.prototype._getCustomSinglePagination = function (page_class, func_name, parameter, page_num){
    var param = "'" + parameter.join("','") + "'"; //join()  : ()에것으로 배열을 문장으로 연결해줌
    page_class = '\'' + page_class + '\'';
    
    return "<span class="+ page_class +" onclick="+this._grid_class+"._" + func_name + "(" + param + ")>" + page_num + "</span>"; 
    
};

//현재 페이지외에 페이지부분
EcoGrid.prototype._getSinglePagination = function (page_num){
    var param = [this._gridid, page_num];
    return this._getCustomSinglePagination('page', 'goSelectedPage', param, page_num);
};

//현재 페이지
EcoGrid.prototype._getSinglePaginationBold = function (page_num){
	//현재 페이지 번호 저장
	currentPage = page_num; 
	var param = [this._gridid, page_num];
    return this._getCustomSinglePagination('page cur_page', 'goSelectedPage', param, page_num);
};

// 페이지네이션 처음 (<<)
EcoGrid.prototype._getFirstPagination = function (){
    var param = [this._gridid];
    /*var icon = '<i class="glyphicon glyphicon-fast-backward"></i>';*/
    var icon = '&lt;&lt;';
    return this._getCustomSinglePagination('goto first', 'goFirstPage', param, icon);
};


//페이지네이션 다음 (>)
//2018.02.13 강예슬 추가 - 이전/다음 버튼 제대로 수행되도록 수정
//EcoGrid.prototype._getNextGroupPagination = function (page_num){
EcoGrid.prototype._getNextGroupPagination = function (page_num,total_page_num){
    var param = [this._gridid, page_num];
    
    //2018.02.13 강예슬 추가 - 이전/다음 버튼 제대로 수행되도록 추가
    if(page_num < total_page_num){
    	var param = [this._gridid, Number(page_num)+1];
    }
    
    /*var icon = '<i class="glyphicon glyphicon-chevron-right"></i>';*/
    var icon = '&gt;';
    return this._getCustomSinglePagination('goto next', 'goSelectedPage', param, icon);
};

//페이지네이션 이전 (<)
EcoGrid.prototype._getPrevGroupPagination = function (page_num){
    var param = [this._gridid, page_num];
    /*var icon = '<i class="glyphicon glyphicon-chevron-left"></i>';*/
    
    //2018.02.13 강예슬 추가 - 이전/다음 버튼 제대로 수행되도록 추가
    if(page_num > 1){
    	var param = [this._gridid, Number(page_num)-1];
    }
    
    var icon = '&lt;';
    
    return this._getCustomSinglePagination('goto prev', 'goSelectedPage', param, icon);
};

//페이지네이션 끝 (>>)
EcoGrid.prototype._getLastPagination = function (total_data_num){
	
    var param = [this._gridid,total_data_num,this._rowNum];
    /*var icon = '<i class="glyphicon glyphicon-fast-forward"></i>';*/
    var icon = '&gt;&gt;';
    return this._getCustomSinglePagination('goto last', 'goLastPage', param, icon);
};


//맨 처음 페이지로 이동
EcoGrid.prototype._goFirstPage = function (){
	this._goSelectedPage(this._gridid, 1);
};

//맨 끝 페이지로 이동
EcoGrid.prototype._goLastPage = function (table_selector,total_data_num,rowNum){
	
    var total_records = total_data_num;
    var total_page = Math.ceil(total_records /rowNum);

    this._goSelectedPage(table_selector, total_page);
};


// 페이지 클릭시 실행되는 함수 (클릭된 페이지로 이동시켜준다)
EcoGrid.prototype._goSelectedPage = function(table_selector, page_num) {
	
	if (this._pagingType == "grid_type") { // 그리드 페이징일때
		
		this._page = page_num; // 페이지번호 이동을 위해 클릭된 페이지를 현재 페이지로 넣고 그리드 리로드
		$(table_selector).jqGrid('setGridParam', {
			page : page_num,
			gridComplete : this._gridComplete(this)
			// 그리드 페이징시 페이지 이동을 보여주는 div에대한 이동을 보여주려 this._gridComplete을 실행
		}).trigger("reloadGrid");
		
	} else {
		if (this._global_call != undefined) { // 페이징 분리일때
			this._global_call(page_num, this._sort_field, this._sort_option);
		}
		
	}
};




// 데이터의 총 갯수 그리기
EcoGrid.prototype._TotalRowInPagination = function (obj){
	if(obj._totalCount==undefined){
		obj._totalCount = 0;	
	}
		//console.dir(obj);
		//20.01.30 이현주 - multiselect 가 false인 경우 한개만 선택할 수 있기때문에 total 건수만 나오도록 수정
		var showSelectCntOrNot = obj._multiselect == true ? "<em id='"+obj._grid_class+"grid_select_cnt'>0</em> /" : '';
			
	    $(obj._pagination_id).closest('.metis_pagination').find('.search_filter')
	        .empty()
	        .append("<span>Total :" + showSelectCntOrNot + "<em>" + obj._totalCount + "</em> 건</span>");

	    gridTotalCount = obj._totalCount;
	    
};


	
	
	
	
	
/*****************************************************************************************************************공통함수*/	
	
	
	
//선택된 row를 this._multiselect따라 분리 후 rowdata 추출	
EcoGrid.prototype.gridRowData = function (){
	
	if(this._multiselect==false){
		rowid = $(this._gridid ).getGridParam("selrow");
		if(rowid == null || rowid == undefined)
		{
			rowdata = null;
		}
		else
		{
			rowdata = $(this._gridid).getRowData(rowid);
		}
		
		return rowdata;
		
	}else{
		rowid=$(this._gridid).jqGrid("getGridParam","selarrrow");
		var rowdata_Array=[];
		for(var i=0; i< rowid.length;i++){
			rowdata = $(this._gridid).getRowData(rowid[i]);
			rowdata_Array.push(rowdata);
		}
		return rowdata_Array;
	}
};

// 선택된 row를 this._multiselect에 상관없이 array로 반환한다. 없으면 length = 0
// {label:"REC_KEY", name:"SPECIES_KEY", hidden:true, key:true } 처럼 key:true 가 있어야 정상작동 없으면 false로 들어갈 수 있음
EcoGrid.prototype.gridRowDataArray = function (){
	var rowdata_Array=[];
	if(this._multiselect==false){
		rowid = $(this._gridid ).getGridParam("selrow");
		if(rowid != null && rowid != undefined)
		{
			rowdata_Array.push($(this._gridid).getLocalRow(rowid));
		}
	} else {
		rowid=$(this._gridid).jqGrid("getGridParam","selarrrow");
//		console.dir(rowid);
		for(var i=0; i< rowid.length;i++){
//			console.log(rowid[i]);
			rowdata_Array.push($(this._gridid).getLocalRow(rowid[i]));
		}
	}
	
	return rowdata_Array;
};

//멀티셀렉트 또는 선택여부 상관 없이 그리드내에 모든 데이터 배열 반환
EcoGrid.prototype.gridAllRowDataArray = function() {
	
	var tmp = $(this._gridid).jqGrid("getGridParam","data");
	if( Object.prototype.toString.call( tmp ) === '[object Array]' ) {
		return tmp;
	} else {
		return [];
	}
}

EcoGrid.prototype.getRowCount = function() {
	rowid=$(this._gridid).jqGrid("getGridParam","data");
	if(rowid != null && rowid != undefined)
		return rowid.length;
	return 0;
};

//그리드 데이터 초기화
EcoGrid.prototype.clearGridData = function (){
	$(this._gridid).clearGridData();
	this._gridTypePrint("","");
};

//그리드 체크박스 선택
EcoGrid.prototype.setSelection = function (id){
	$(this._gridid ).jqGrid('setSelection',id);
};

//그리드 전체선택
// 멀티 선택의 경우만 진행된다.
EcoGrid.prototype.setSelectAll = function (){
	
	var ch_id = "#cb_" + strReplaceAll(this._gridid, "#", ""); 
	$(ch_id).trigger('click');
};

// 그리드의 첫번째 데이터를 서정한다.
EcoGrid.prototype.setFirstDataSelect = function (){
	
	$(this._gridid ).jqGrid('setSelection',id);
	
};




// 그리드 선택정보 초기화
EcoGrid.prototype.resetSelection = function () {
	$(this._gridid).jqGrid('resetSelection');
};

// 그리드 변경사항 적용
EcoGrid.prototype.reloadGrid = function() {
	$(this._gridid).trigger('reloadGrid');
}

// id에 해당하는 row의 색상 변경
EcoGrid.prototype.setRowData = function (id,color) {
	$(this._gridid).setRowData(id,false,{background:"#" + color});
};


// 현재 페이지 번호를 보여줌
EcoGrid.prototype.getCurrentPage = function () {
	return currentPage;
};


//총 레코드수를 검색
EcoGrid.prototype.getGridTotalCount = function () {
	
	
	return gridTotalCount;
};


// 그리드 전체 데이터 가져오기
EcoGrid.prototype.getGridAllData = function () {
	
	var data = $(this._gridid).getRowData();
//	var data2 = $(this._gridid).getGridParam("data");
	
	return data;
};

// 해당 데이터 삭제
EcoGrid.prototype.delRowData = function (id) {
	
	var data = $(this._gridid).jqGrid('delRowData',id);	
	return data;
	
};

// 엑셀 출력시 어떤 형태로 출력할지 결정한다. 
//subTitle:부제
//searchData:검색조건
//printType: 전체출력/ 선택출력  (all/check)
// 21.01.15 chong 개인정보출력 로그 내역 insert을 위해 callback 추가
EcoGrid.prototype.exportExcel = function(pFileName,title,subTitle,searchData,printType,callback) { 

	var msExcel 	= this.msExcel;
	var exportHcell = this.exportHcell
	var directPrint_jq = this.directPrint_jq
	var obj = this;
	
	var currentUserInfo = JSON.parse(localStorage.getItem('current_user_info'));
	
	if(callback != undefined && currentUserInfo.PRIVACY_PRINT_LEVEL == '1'){
		onlyMessage('이용자의 개인정보가 포함된 목록(엑셀, 목록, 리포트 등)의 출력이 제한된 계정이므로 출력이 불가능합니다.');
		return;
	}
	if(this._multiselect	== false)
	{
		msExcel(obj,pFileName,title,subTitle,searchData,"all");
	}
	else
	{
		openMessagePopup({
	        title        : "출력",
	        msg          : "출력할 형태를 선택해 주세요",
	        btn1_text    : "전체자료",
	        btn1_function: function(e) { 
					if(callback != undefined && callback.name == 'insertPrivacyPrintLog'){
						print_reason_popup(function(reason){msExcel(obj,pFileName,title,subTitle,searchData,"all",callback,reason)})
					}else{
						msExcel(obj,pFileName,title,subTitle,searchData,"all",callback)
					} 
				},
	        btn2_text    : "선정자료",
	        btn2_function: function(e) { 
					if(callback != undefined && callback.name == 'insertPrivacyPrintLog'){
						print_reason_popup(function(reason){msExcel(obj,pFileName,title,subTitle,searchData,"SELECT",callback,reason)})
					}else{
						msExcel(obj,pFileName,title,subTitle,searchData,"SELECT",callback)
					}
				},
	        
	//        btn2_text    : "일반출력",
	//        btn2_function: function(e) { directPrint_jq(obj,pFileName,title,subTitle,searchData,printType)},
	//        btn3_text    : "한셀",
	//        btn3_function: function(e) { exportHcell(obj,title) }
		});
	}
	
	
	
//	alert("export");
//    this.exportHcell(title);
//	return;
};

// 일반 프린터로 직접 출력
EcoGrid.prototype.directPrint_jq= function(obj,pFileName,title,subTitle,searchData,printType) {
	var datahtml = obj.exportPop(pFileName,title,subTitle,searchData,printType);
	
	// 바로 출력하는 함수 호출
	com_direct_print(datahtml);
	
}



//엑셀 출력
//pFileName : 엑섹 파일명
//title : 출력될 엑셀의 제목
EcoGrid.prototype.msExcel= function(obj,pFileName,title,subTitle,searchData,printType,callback,reason) {
	 
	
	var excel_export_type = getViewOptionData_value('엑셀출력방식',localStorage.getItem('current_user_manage_code'));
	if(undefined != excel_export_type && null != excel_export_type && 'LOCAL' == excel_export_type){
		// 엑셀 반출을 화면에서 직접 해결하는 방식 추가
		getGridDataExport(obj._gridid,obj._colModel, printType, 'jqgrid');
		return;
	}	
	
	var pGridObj = $(obj._gridid );
	var mya = pGridObj.getDataIDs();
    var data = pGridObj.getRowData(mya[0]);     
    var colNames=new Array();
    var ii=0;
    for (var d in data){ colNames[ii++] = d; }    

    //컬럼 헤더 가져오기 
    var columnHeader = pGridObj.jqGrid('getGridParam','colNames') + '';
    var colModel = pGridObj.jqGrid('getGridParam','colModel');    
    
    if (title == undefined) {
	   	title = "";
    };
    if (subTitle == undefined) {
    	subTitle = "";
    };
    
  var viewCol = [];

    //검색조건 넣기
    if(searchData == undefined){
    	searchData = "";
    }else{};
    
//헤더
	var header = [];
    for ( var y = 0; y < colModel.length; y++ ) {
    	var col = colModel[y];
    	if(colModel[y].hidden == false && colModel[y].name != "cb")
		{
    		console.log("["+colModel[y].label+"]["+colModel[y].name+"]");
    		header.push(colModel[y]?.label?.replace(/,/g,""));		//헤더에 , 가 있는 경우 값이 밀리는 문제가 있어 제거
    		viewCol.push(colModel[y].name);
		}
         
    }
    
    var total_data = [];
	  if(printType=='all' || printType == undefined || printType == ""){
	  	
	  	total_data = obj.gridAllRowDataArray();
	  }else{
	  	total_data = obj.gridRowData();
	  	
	  }
	  
	//  console.dir(total_data);
    
    var param = {};
    param.title       	= title;
    param.subTitle    	= subTitle;
    param.pFileName   	= pFileName;
    param.total_data	= JSON.stringify(total_data)	 //데이터
    param.header 		= header.join(",");   	//컬럼값
    param.viewCol 		= viewCol.join(",");  	//쉘의 이름
    if(searchData==""){
    	param.searchData	= "";
    }else{
    	param.searchData	= JSON.stringify(searchData);
    	
    }

    console.dir(param);
	
	$.post(
	'/METIS/common/getExcelExport.do'
	,param
	,function(data) 
	{
		if(data.status == "success"){
			
			if(callback){
				callback(total_data,reason);
			}

			window.location = data.downLoadURL;
			
		}else{
			onlyMessage("오류가 발생했습니다.")
			
		}
	}


);	
    
//    $.ajax({
//		type    : "POST",
//		url     : "/METIS/common/getExcelExport.do",
//		dataType: "json",
//		data    : param,
//		success : function(obj) {
//
//		}
//	});
    
    
}

// 엑셀로 출력할 데이터를 새로운 row에  한꺼번에 그려서 가졍져오는함수 (formater때문에 따로 한번 더 그려서 데이터를 가져옴)
var ecxelTotalData_grid;

EcoGrid.prototype.ecxelTotalData= function() {

	$(".metis_container").append("<div class='table_container' style='display: none;'>" +//style='display: none;
			" <table id='ecxelTotalData_contents' style='visibility : collapse;'> </table>" + 
			"</div>");
	
	var table_id ="#ecxelTotalData_contents";
	
	var option={
			rowNum:5000,
			grid_class:"ecxelTotalData_grid",
      		gridPaging:false,
	 		pagingType:"grid_type",
	 		multiselect : true
	};
	
	
	ecxelTotalData_grid = new EcoGrid(table_id,this._colModel,'',option);
	ecxelTotalData_grid._gridTypePrint(this._data,option);
	
	//var allData = ecxelTotalData_grid.getGridAllData();
	var allData1 = $(""+table_id+"").jqGrid('getDataIDs')
	var data = [];
	for(var i in allData1){
		data.push(ecxelTotalData_grid.getRowidData(allData1[i]))
	}
	
	return data;
};



//선택한 그리드의 id 가져오기 (하나의 데이터)
EcoGrid.prototype.getRowid= function() {
	var rowid =  $(this._gridid).getGridParam('selrow');
	return rowid;
};
//선택한 그리드의 id 가져오기 (여러개 데이터)
EcoGrid.prototype.getRowidMult= function() {
	var rowid =  $(this._gridid).getGridParam('selarrrow');
	return rowid;
};

//rowid 로 데이터 가져오기 
EcoGrid.prototype.getRowidData= function(rowid) {
	var rowdata =  $(this._gridid).getRowData(rowid);
	return rowdata;
};


EcoGrid.prototype.exportHcell = function (obj,title) {

	var g_HCell;
	g_HCell = new ActiveXObject("HCell.Application");
    g_HCell.Visible = 1;
    
    var oSheet = g_HCell.ActiveSheet;
    var oCell;
    var pGridObj = $(obj._gridid);
    
    var colModel = pGridObj.jqGrid('getGridParam','colModel');
    var xlCenter = -4108;
    
    
    
    var col_al = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","Y","U","V","W","X","Y","Z"];
    var col_overIndex = -1;
    var col_index = 0;
    var viewCol = [];
    for ( var y = 1; y < colModel.length; y++ ) {
    	var col = colModel[y];
    	if(colModel[y].hidden == false)
		{
    		oCell = oSheet.Range(col_al[col_index]+"3");
    		oCell.value = colModel[y].label;
    		col_index = col_index + 1;
    		
    		viewCol.push(colModel[y].name);
		}
    }
    
    
    if(undefined != title && null != title)
	{
    	oSheet.Range("A1:"+col_al[col_index-1]+"1").MergeCells = true;
    	oCell = oSheet.Range("A1:"+col_al[col_index-1]+"1");
    	
    	oCell.RowHeight = 50; 
    	oCell.HorizontalAlignment = xlCenter;
        oCell.Font.Bold = true;
        oCell.Font.Size = 20;
        
        oCell.value = title;
	}
    
    
    
    // 전체 데이터 가져오기
    var total_data = obj.ecxelTotalData();

	//값 불러오기
	for(var i=0;i< total_data.length;i++) {
	
      data = total_data[i];

      for(var j in viewCol)
      {
    	  oCell = oSheet.Range(col_al[j]+""+(i+4));
    	  oCell.value = data[viewCol[j]];
  		 //html=html + '<td>' + data[viewCol[j]]+"</td>"; 
      }
	}
	
	var xlContinuous = 1;
    var xlThin = 2;
    var xlAutomatic = -4105;
    

    

    // 헤더 스타일 적용
    oCell = oSheet.Range("A3:" + col_al[(viewCol.length-1)] + "3");
    oCell.HorizontalAlignment = xlCenter;
    oCell.Font.Bold = true;
    oCell.Interior.Color = f_convert_rgb(166,166,166);
	oSheet.UsedRange.Columns.AutoFit();

	// 전체 줄그리기
    oCell = oSheet.Range("A3:" + col_al[col_index-1]+ "" + (total_data.length+3));
    oCell.Borders.LineStyle = xlContinuous;
    oCell.Borders.Weight = xlThin;
    oCell.Borders.ColorIndex = xlAutomatic;
    
};

function f_convert_rgb(r, g, b) {
	return r + (256*g) + (65536*b);
}

//엑셀 출력
//pFileName : 엑섹 파일명
//title : 출력될 엑셀의 제목
EcoGrid.prototype.exportPop= function(pFileName,title,subTitle,searchData,printType) {
  
  var obj = this;

  var pGridObj = $(obj._gridid );
  var mya = pGridObj.getDataIDs();
  var data = pGridObj.getRowData(mya[0]);     
  var colNames=new Array();
  var ii=0;
  for (var d in data){ colNames[ii++] = d; }    

  //컬럼 헤더 가져오기 
  var columnHeader = pGridObj.jqGrid('getGridParam','colNames') + '';
  var colModel = pGridObj.jqGrid('getGridParam','colModel');
  
  
  if (title == undefined) {
	   	title = "";
  };
	    
  
  var arrHeader = columnHeader.split(',');
 // var html="<table border=1><tr>";
  var html = "<div id=print_pop>";
  html += "<div id=print_pop_condition>";
  html += "<h4 style='font-size: 30px;font-weight: bold;text-align: center;'>"+title+"</h4>";
  
  if (subTitle == undefined || subTitle=="") {
	  
  }else{
  	html = html + "<h1 style='font-size: 15px;font-weight: bold;text-align: center;'>"+subTitle+"</h4>";
  	
  }
  
  var viewCol = [];
  
  //검색조건 넣기
  if(searchData == undefined || searchData==""){
  	
  }else{
  	
  	html= html + "<table style='text-align: left;'>";
  	
  	
  	//3칸
  	for(var i=0;i<= searchData.length; i++){
  		if(i==0){
  			var text1 = i+1;
  			var text2 = i+2;
  			html = html + "<tr>";
  			html = html + "<td>"+searchData[i].text+" : "+searchData[i].value+"</td>";
  			
  			if(i == searchData.length || text1 == searchData.length || text2 == searchData.length){
  				break;
  			}else{
  				
  				if(text1 <=searchData.length ){
  					html = html + "<td></td>";
  					
  					html = html + "<td>"+searchData[text1].text+" : "+searchData[text1].value+"</td>";
  					if(text2 <=searchData.length){
  						html = html + "<td></td>";
  						html = html + "<td>"+searchData[text2].text+" : "+searchData[text2].value+"</td>";
  					}
  				}
  			}
  			
  			html = html + "</tr>";
  		
  		}else{
  			var index = i*3;
  			var index1 = index+1;
  			var index2 = index+2;

  			if(index == searchData.length || index1 == searchData.length || index2 == searchData.length){
  				break;
  			}else{
  				
  				html = html + "<tr>";
  				html = html + "<td>"+searchData[index].text+" : "+searchData[index].value+"</td>";
  				
  				if(index1 <=searchData.length ){
						html = html + "<td></td>";
      				html = html + "<td>"+searchData[index1].text+" : "+searchData[index1].value+"</td>";
      				if(index2 <=searchData.length){
  						html = html + "<td></td>";
      					html = html + "<td>"+searchData[index2].text+" : "+searchData[index2].value+"</td>";
      				}
      			}
  				html = html + "</tr>";
  			}
  			
  		}
  		

  		html=html+"</table>"; 
  		
  		html=html+"<p>"; 
  		
  		
  	}
  	
  }
  html= html + "</div>";
  
  html= html + "<table border=1 id=print_pop_table border='0' cellspacing='0' cellpadding='0'><tr>";
  
//  var name = "제목테스트";
//  html = html + "<thead style='font-size: 20px; font-weight: bold;'>"+name+"<thead>";
  
  for ( var y = 1; y < colModel.length; y++ ) {
  	var col = colModel[y];
  	if(colModel[y].hidden == false)
		{
  		html = html + "<td style='background-color:#CCCCCC;width:150px;mso-number-format:\@'><b>" + colModel[y].label  + "</b></td>";
  		viewCol.push(colModel[y].name);
		}
       
  }
  

  html = html + "</tr>";

  // 전체 데이터 가져오기
  var total_data = [];
  if(printType=='all' || printType == undefined || printType == ""){
  	
  	total_data = obj.ecxelTotalData(obj);
  }else{
  	total_data = obj.gridRowData();
  	
  }
  
//  console.log("데이터 가져오기 "+dataType);
//  console.dir(total_data);
  
	//값 불러오기
	for(var i=0;i< total_data.length;i++) {
    html = html +"<tr>";	
    data = total_data[i];

    for(var j in viewCol){
  	  var view_data = data[viewCol[j]];
  	  if(view_data == "")
		  {
  		  view_data = "&nbsp;";
		  }
		 html=html + "<td style='mso-number-format:\\@'>" + view_data+"</td>"; 
		}
	
    html = html+"</tr>";  
	
	}
	
	console.log(html);

//  //값 불러오기
//  for(var i=0;i< mya.length;i++) {
//       var datac= pGridObj.getRowData(mya[i]); 
//       html = html +"<tr>";
//       for(var j=0; j< viewCol.length;j++) html=html + '<td>' + encodeURIComponent(datac[viewCol[j].name])+"</td>"; 
//       html = html+"</tr>";  
//  }


  html=html+"</table>";  // end of line at the end
  html=html+"</div>";  // end of line at the end
  
  return html;
}

//전체 그리드id 가져오기 
EcoGrid.prototype.getDataIDs = function() {
	return $(this._gridid).getDataIDs();
};

// getRowData 로 데이터 가져올 때 마지막 데이터 하나가 누락되는 현상으로 인해 하나씩 가져와서 리턴하도록 추가
EcoGrid.prototype.getAllRowDatas = function() {
	const grid = $(this._gridid);
	const allRowIds = grid.getDataIDs();
	
	const allRowDatas = allRowIds.map(function(rowId) {
	    return grid.getRowData(rowId);
	});
	
	return allRowDatas;
};

/**
 * 24.11.12 최연희 - 그리드 행 키보드 방향키로 제어 가능하게 하는 메서드 추가
 * onEnter: null,
 * onSpace: null,
 * onLeftKey: null,
 * onRightKey: null,
 * scrollingRows : true
 */
EcoGrid.prototype.keyNavigate = function(keyNavigateParam) {
	$(this._gridid).focus();
	$(this._gridid).jqGrid('bindKeys', keyNavigateParam);
};