package com.dbs.consent.demo.consent;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Build;
import android.text.InputType;
import android.text.method.PasswordTransformationMethod;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

import com.dbs.consent.demo.BuildConfig;
import com.dbs.consent.demo.R;
import com.dbs.consent.demo.activity.ConsentActivity;
import com.dbs.consent.demo.consent.sign.SignWrapper;
import com.dbs.consent.demo.util.ConsentConfig;
import com.dbs.consent.demo.util.Util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import kr.co.clipsoft.eform.EFormToolkit;
import kr.co.clipsoft.eform.information.RunOption;
import kr.co.clipsoft.eform.type.enumtype.LogLevel;
import kr.co.clipsoft.eform.type.enumtype.Position;
import kr.co.clipsoft.eform.type.enumtype.ScreenOrientation;
import kr.co.clipsoft.eform.type.enumtype.TempSaveCheck;

import static android.content.Context.INPUT_METHOD_SERVICE;

public class ConsentFacade {
  private static final String TAG = "ConsentFacade";
  private Context mContext;
  private ConsentActivity instance;

  private EFormToolkit eFormToolkit;

  public ConsentFacade(Context mContext) {
    this.mContext = mContext;
    this.instance = (ConsentActivity) mContext;
    this.eFormToolkit = new EFormToolkit(mContext);
  }

  private RunOption getRunOption(String consentMstRid) {

    RunOption runOption = new RunOption();
    runOption.setToolbarDoubleTapHide(true); // 화면 더블 탭시 툴바가 사라지고 나타나는 옵션
    runOption.setScreenOrientation(ScreenOrientation.Sensor); // 화면 회전 옵션
    runOption.setFirstPageLoad(true); // 서식 로딩시 첫 페이지만 로딩할지 여부 true : 서식 로딩 시 첫 페이지 우선 로딩, false : 전체 페이지 로딩
    runOption.setPageTouchEnable(true); // 전체 위젯 터치 여부를 설정함 true : 전체 위젯 터치 가능, false : 전체 위젯 터치 불가
    runOption.setDefaultZoomRate(1); // 화면 최초 로딩 시 서식 scale 크기 설정 1 ~ 4 default value : -1.0 (임의 조정하지 않음)
    runOption.setInitializeScrollOnPageMove(true); // 서식 페이지 이동시 스크롤 초기화 여부 true : 이동시 초기화, false : 초기화 하지 않음
    runOption.setInitializeScaleOnPageMove(true); // 페이지 이동시 scale 초기화 여부 true : 초기화, false : 초기화 하지 않음
    runOption.setExternalControlDefinedPath(BuildConfig.CONSENT_EFORM_SERVER_URL);

    if (consentMstRid.equals("0")) {
      runOption.setParameterDefaultValueClear(true); // 서식에 저장되어 있는 파라미터 값 초기화 여부 true : 초기화, false : 초기화 하지 않음
    } else {
      runOption.setParameterDefaultValueClear(false); // 서식에 저장되어 있는 파라미터 값 초기화 여부 true : 초기화, false : 초기화 하지 않음
    }

    runOption.setLogLevel(LogLevel.INFO); // 레벨에 맞는 로그를 기록함
    runOption.setFosLogging(true); // FOS를 파일로 로깅할지 여부를 설정함 true : FOS를 파일로 로깅함, false : 로깅하지 않음
    runOption.setUseCaching(false); // 로컬 파일을 생성하여 캐싱할지 여부를 설정 true : 캐싱, false : 캐싱하지 않음
    runOption.setUseSaveConfirmDialog(true); // 저장 시 확인 팝업 출력 여부 true : 팝업 사용, false 팝업 X
    runOption.setUseTempSaveConfirmDialog(true); // 임시저장 시 확인 팝업을 사용할지 여부를 설정함 true : 팝업 사용, false : 팝업 X
    runOption.setUseTempSave2ConfirmDialog(true); // 임시저장2 시 확인 팝업을 사용할지 여부를 설정함 true : 팝업 사용, false : 팝업 X
    runOption.setUseExitConfirmDialog(true); // 종료 시 확인 팝업을 사용할지 여부를 설정함 true : 팝업 사용, false : 팝업 X
    runOption.setReturnDataXmlOnSave(true); // 저장버튼 클릭 시 데이터 xml을 리턴 받을지 여부를 설정함 true : 리턴 받음, false : 리턴 받지 않음
    runOption.setDataXmlSaveAsFileOnSave(false); // 저장 시 데이터를 xml 문자열 형태로 받을지, 파일로 저장 후 저장된 파일의 path로 받을지 설정함  true : 로컬에 저장후 경로 반환, false : xml 문자열 반환
    runOption.setReturnImageOnSave(true); // 저장버튼 클릭 시 이미지 저장 여부를 설정함 true : 이미지 저장, false : 이미지 저장 X
    runOption.setDataXmlSaveAsFileOnTempSave(false); // 임시저장 시 dataXml 리턴 시 file 여부(true : file, false : String)
    runOption.setReturnDataXmlOnTempSave(true); // 임시저장 시 데이터 XMl도 함께 저장할지 여부를 설정함 true : 함께 저장, false : 저장 X
    runOption.setDataXmlSaveAsFileOnSave(false); // 저장 시 데이터를 xml 문자열 형태로 받을지, 파일로 저장 후 저장된 파일의 path 로 받을지 설정함 true :  로컬에 저장 후 경로 반환, false : xml 문자열 반환
    runOption.setIncludesDrawingOnDataXml(false); // 저장시 펜 드로잉 정보를 포함하여 저장할지 여부를 설정함 true : 펜 드로잉 정보를 포함하여 저장, false : 펜 드로잉 정보를 포함하여 저정 X
    runOption.setImageSaveOption("{'encode':'jpg', 'start-index':0, 'quality':100, 'dpi':150, 'gray':false}"); // 저장될 이미지 타입을 설정함
    runOption.setIncludesDrawingOnTempDocument(true); // 임시저장 시 펜 드로잉 정보를 포함하여 저장할지 여부를 설정함 true : 포함하여 저장, false : 포함하여 저장 X
//    runOption.setParameterAsFileNameOnSave(""); // 저장 시 파일이름으로 사용될 파라미터 필드명을 설정함
//    runOption.setCheckTempSaveFileWhenDocumentLoad(false); // 임시저장 파일 저장 경로에 기존 임시저장 파일이 있으면 기존 서식을 불러올지 묻는 다이얼로그를 사용할지 여부를 설정함 setParameterAsFileNameOnSave 옵션으로 파일명이 설정되어 있어야 사용 가능함
//    runOption.setDeleteLocalTempFileOnSave(false); // 저장 시 임시저장 파일 저장 경로(로컬)에 임시저장 파일이 있으면 임시저장 파일을 삭제할지 여부를 설정함 setParameterAsFileNameOnSave 옵션으로 파일명이 설정되어 있어야함
//    runOption.setDrawingPen(""); // 펜의 최초 두께, 투명도, 색상을 json으로 설정함
    runOption.setPreventScreenCapture(false); // 화면 캡쳐 방지 여부 true : 캡쳐방지, false : 캡쳐방지 X
    runOption.setUrlConnectTimeoutInMilisecond(10 * 1000); // 서식을 불러 올 시 Url Connection time out을 설정함 1000 = 1초
    runOption.setIncludesChangedFormOnDataXml(true); // 저장 시 화면의 변경 사항을 포함하여 저장할지 여부를 설정함 true : 변경사항 포함 저장, false : 변경사함 포함 저장 X
    runOption.setSaveRecordFileIntoMultipleParts(true); // 음성 녹음을 여러번 했을때 덮어 쓸지 여부 설정 true : 여러 파일로 저장, false : 덮어씀 대가대는 음성녹음 기능 쓰지 않음

    runOption.setSecureTempSave(false); // 임시저장 암호화 여부 true : 암호화, false : 암호화 X
    runOption.setSecureSave(false); // 저장시 암호화 여부 true : 암호화, false : 암호화 X
    runOption.setOpenOnlyDeviceGeneratesAnSecureTempFile(false); // 임시저장 파일을 암호화여 저장시 저장한 기기에서만 열게 할지 여부 설정 true : 저장한 기기에서만 열수있게, false : 다른 기기에서도 열 수 있게 처리
//    runOption.setSecureKey("jksongDcmc1234!Sungwoo#%&@*(QWER"); // 암호화 시 사용될 키 설정 길이가 16byte이면 AES-128, 32byte이면 AES-256

    runOption.setReturnTempDocumentOnSave(true); // 저장 시 임시저장 데이터를 반환할지 여부를 설정함 true : 저장 시 임시저장 데이터 반환, false : 반환하지 않음
    runOption.setIncludesDataFieldDescriptionOnDataXml(false); // DataXml의 데이터 필드 노드에 설명 속성을 포함할지 여부를 설정함 true :  설명 속성 포함, false : 속성 포함 X
    runOption.setReturnDataXmlOnTempSave2(true); // 임시저장2 시 데이터 xml도 함께 저장할지 여부를 설정함 true : 함께 저장, false : 저장 X
    runOption.setPreventFingerTouchEvent("{'signature':'false'}"); // Viewer 동작 시 손으로 터치하는 동작을 방지할지 여부를 설정함 true : 손으로 입력 불가능, false : 손으로 입력가능
//    runOption.setExternalControlDefinedPath(""); // 외부 사용자 정의 컨트롤의 정보를 갖는 서버 URL을 설정함
    runOption.setCollaborativeCompanyInformation(""); // 협업하는 회사의 정보를 Json 형태로 설정함
    runOption.setReturnImageOnTempSave(false); // 임시저장 시 이미지를 저장할지 여부를 설정함
    runOption.setReturnTempDocumentOnTempSave(true); // 임시저장 시 ept(임시저장파일)를 생성할지 여부를 설정함 true : 임시저장시 ept파일 생성, false : 생성하지 않음

    runOption.setRequiredCheckOnTempSave(false); // 임시저장시 필수 입력 체크를 할지 여부를 설정함 true : 필수 입력 체크 수행, false : 필수 입력 체크 수행 X

    runOption.setReturnImageOnTempSave2(true); // 임시저장2시 이미지를 저장할지 여부를 설정함 true : 이미지 저장, false : 이미지 저장 X
    runOption.setReturnTempDocumentOnTempSave2(true); // 임시저장2 시 ept(임시저장파일)를 생성할지 여부를 설정함 true :  ept 파일 생성, false : ept 파일 생성 X
    runOption.setRequiredCheckOnTempSave2(true); // 임시저장2 시 필수 입력 체크를 할지 여부를 설정함 true : 필수 입력 체크 수행, false : 필수 임력 체크 수행 X
    runOption.setTempFileSaveOnPrivateFolder(false); // 임시저장 파일을 히든 영역에 저장할지 여부를 설정함 단, 히든 영역에 저장시킬 경우, Viewer 앱을 제외한 다른 앱에서 접근할 수 없음 true : 히든 영역에 저장, false : 외부 영역에 저장
    runOption.setUseNextDocumentOpenDialogAfterSave(false); // 연속출력 시 저장 후 다음 서식을 불러올지 선택하는 다이얼로그를 사용할지 여부를 설정, 사용 안 함으로 설정하면 바로 다음 서식을 부름 true : 다이얼로그 사용, false : 다이얼로그 사용 X
    runOption.setUseReLoadDialogOnDocumentLoadFail(false); // 서식 불러오기 실패 시 다시 불러올지 묻는 다이얼로그 사용 여부 ture : 사용, false : 미사용
    runOption.setEnableRequiredErrorPopupContentsLineFeed(false); // 필수 입력 오류 팝업 리스트의 개행 여부를 설정함 true : 개행, false : ", " 구분
    runOption.setAutoTempSave(false); // 자동 임시저장 여부 설정 true : 자동 임시저장, false : 자동 임시저장 하지 않음
//    runOption.setAutoTempSaveTimeInSecond(0); // 자동 임시저장 주기를 설정함 setAutoTempSave가 true 일때만 사용함 (단위 : 초)
    runOption.setCallSaveEventOnNextPageMoveAtLastPage(false); // 마지막 페지이에서 다음 페이지 이동 시 저장 이벤트를 호출 여부
    runOption.setIconModeToInputOrderButton(false); // 입력 순서의 이전, 다음 버튼을 아이콘으로 표현할지 여부를 설정 true : 아이콘, false : 텍스트
    runOption.setIconModeToSignatureButton(false); // 서명 컨트롤 입력 시 확인, 닫기, 초기화, 삭제 버튼을 아이콘으로 표현할지 여부를 설정 true : 아이콘, false : 텍스트
    runOption.setRunAsRepositoryV2(true);
    runOption.setDisplaySaveConfirmDialogBeforeRequiredCheck(true); // 저장, 임시저장시 필수 입력 체크 확인
    runOption.setAlwaysDisplayRequiredInput(false); // 필수입력 표시를 항상할지
    runOption.setSameCheckAsSaveWhenTempSave2(TempSaveCheck.Always);
    runOption.setInactivityTimeoutExit(true); // 지정한 시간동안 동작이 없으면 경고창 출력 후 종료 이렇게 종료된 서식은 저장, 임시저장이 되지 않음
    runOption.setInactivityTimeoutInMilisecond(1000 * 60 * 60); //지정한 시간 1000 = 1초

    runOption.setUiStyle(getUiStyle());

    // 디버그용 런 옵션


    return runOption;
  }

  public void startConsent(String consentMstRid, HashMap consentData, String certPass, String apiType) {
//    HashMap<String, String> globalParam = (HashMap<String, String>) consentData.get("globalParam");
//    ArrayList<HashMap<String, String>> formList = (ArrayList<HashMap<String, String>>) consentData.get("formListParam");

    String userId = Util.getStringPreference(mContext, "userInfo", "userId");
    String fos = createFOS(consentData);

//    Log.e(TAG, "create fos -- > " + fos);
    Util.LOG(ConsentFacade.class, "create fos -- > " + fos);

    eFormToolkit.setExitEventHandler(new EformExitEventHandler());
    eFormToolkit.setResultEventHandler(new EFormSaveHandler(mContext, eFormToolkit, consentData, apiType));

    eFormToolkit.setRunOption(getRunOption(consentMstRid));
    certPass = "Y";
    if (SignWrapper.getInstance().isCertificate(userId) == true || certPass.equals("Y")) {
      String result = eFormToolkit.startEFormViewer(fos);

      if (result.equals("ERROR_004")) {
        return;
      }

      if (!result.equals("SUCCESS")) {
        String message = "";
        if (result.equals("ERROR_000")) {
          message = mContext.getString(R.string.ERROR_000);
        } else if (result.equals("ERROR_001")) {
          message = mContext.getString(R.string.ERROR_001);
        } else if (result.equals("ERROR_002")) {
          message = mContext.getString(R.string.ERROR_002);
        } else if (result.equals("ERROR_006")) {
          message = String.format(mContext.getString(R.string.permissionDenied), mContext.getString(R.string.viewer));
        }
        instance.csAlert.show();
        instance.csAlert.setContent(message, ConsentConfig.ALERT_BTN_TYPE);
        String finalResult = result;
        instance.csAlert.btnConfirm2.setOnClickListener(new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            instance.csAlert.dismiss();
          }
        });
      }

    } else {
      //공인인증 정보가 없을때
      startCertificate(mContext, eFormToolkit, fos, userId);
    }

  }

  private void startCertificate(final Context context, final EFormToolkit eFormToolkit, final String fos, final String userId) {
    final EditText passwordEdit = new EditText(context);
    passwordEdit.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
    passwordEdit.setTransformationMethod(PasswordTransformationMethod.getInstance());
    Util.setCursorColor(passwordEdit, R.color.black);

    final InputMethodManager imm = (InputMethodManager) context.getSystemService(INPUT_METHOD_SERVICE);

    DialogInterface.OnClickListener okListener = new DialogInterface.OnClickListener() {
      @Override
      public void onClick(DialogInterface dialog, int which) {
        String password = passwordEdit.getText().toString();

        try {
          // 인증서 인증
          if (SignWrapper.getInstance().certificate(context, userId, password)) {
            eFormToolkit.startEFormViewer(fos);
          } else {
            Util.getOKDialog(context, context.getString(R.string.emptyCertPw), context.getString(R.string.certAuthFail), null).show();
          }

          imm.hideSoftInputFromWindow(passwordEdit.getWindowToken(), 0);
        } catch (Exception e) {
          e.printStackTrace();
          Util.getOKDialog(context, context.getString(R.string.emptyCertPw), e.getMessage(), null).show();
        }
      }
    };

    DialogInterface.OnClickListener cancelListener = new DialogInterface.OnClickListener() {
      @Override
      public void onClick(DialogInterface dialog, int which) {
        imm.hideSoftInputFromWindow(passwordEdit.getWindowToken(), 0);
      }
    };

    AlertDialog dialog = Util.getPasswordInputDialog(context, context.getString(R.string.emptyCertPw), context.getString(R.string.certAuthFail), okListener, cancelListener);
    dialog.setView(passwordEdit);
    dialog.show();
  }

  private String createFOS(HashMap consentData) {
    String fos = "<?xml version='1.0' encoding='utf-8'?>";
    fos += "  <fos version='1.0'>";
    fos += "    <global>";
    fos += "      <parameters>";
    fos += createParam((HashMap<String, String>) consentData.get("globalParam"));
    fos += "      </parameters>";
    fos += "      <page-template path='" + BuildConfig.CONSENT_EFORM_SERVER_URL + "' request-encode='utf-8' response-encode='utf-8'>";
    fos += "        <template-get-parameters>";
    fos += "          <post-param key='parameter'><![CDATA[{}]]></post-param>"; //페이지 템플릿 리스트에서는 필요한 파라메타가 없음, 추후 확장 될 수 있어 규격만 유지
    fos += "        </template-get-parameters>";
    fos += "      </page-template>";
    fos += "    </global>";
    fos += "    <form-list>";
    fos += formParam((ArrayList<HashMap<String, String>>) consentData.get("formListParam"));
    fos += "    </form-list>";
    fos += "  </fos>";

    return fos;
  }

  private String createParam(HashMap<String, String> param) {
    String paramStr = "";

    if (param != null && !param.isEmpty()) {
      for (String key : param.keySet()) {
        paramStr += "<param key='" + key +"'><![CDATA[" + param.get(key) + "]]></param>";
      }
    }

    return paramStr;
  }

  private String formParam(ArrayList<HashMap<String, String>> formListData) {
    String formStr = "";
    int seq = 0;
    int consentMstRid = 0;
    String path = "";
    if (formListData.size() > 0) {
      for (int i = 0; i < formListData.size(); i++) {
        HashMap<String, String> data = formListData.get(i);
        seq += seq + 1;
        consentMstRid = Integer.parseInt(data.get("rid"));

        if (consentMstRid > 0) {
          path = BuildConfig.CONSENT_SERVER_URL + "FormSvc.aspx/";
        } else {
          path = BuildConfig.CONSENT_EFORM_SERVER_URL;
        }

        formStr += "  <form name=\""+ formListData.get(i).get("par_formNm") +"\" open-sequence='"+ seq +"' path='"+ path +"' request-encode='utf-8' response-encode='utf-8' compression='false'>";
        formStr += "    <form-get-parameters>";
        if (consentMstRid > 0) {
          // 새 서식이 아닌 서식을 불러올때
          formStr += "    <post-param key='use-repository'><![CDATA[false]]></post-param>";
          formStr += "    <post-param key='ConsentMstRid'><![CDATA["+consentMstRid+"]]></post-param>";
        } else {
          // 새 서식을 불러올때
          formStr += "    <post-param key='parameter'>";
          formStr += "      <![CDATA[{'formId':'"+ formListData.get(i).get("formRid") +"', 'formVersion':'-1'}]]>";
          formStr += "    </post-param>";
        }
        formStr += "    </form-get-parameters>";
        if (consentMstRid == 0) {
          formStr += "  <parameters>";
          formStr += createParam(data);
          formStr += "  </parameters>";
        } else {
//          formStr += "  <parameters>";
//          formStr += createParam(data);
//          formStr += "  </parameters>";
          formStr += "  <attachments>";
          formStr += "    <record-files>";
//          formStr +=        recordFileTag(data);
          formStr += "    </record-files>";
          formStr += "  </attachments>";
        }

        formStr += "  </form>";
      }
    }

    return formStr;
  }

  private String getUiStyle() {

    String visible = "false";
    if (!instance.indexPage.equals("O")) {
      if (instance.indexPage.equals("SR")) {
        if (instance.leftMenu.patientState.equals("0")) {
          visible = "true";
        } else {
          if (ConsentConfig.SETTING_DATA.get("ELECTR_CMP").equals("Y")) {
            visible = "true";
          }
        }
      } else {
        if (ConsentConfig.SETTING_DATA.get("ELECTR_CMP").equals("Y")) {
          visible = "true";
        }
      }

    } else if (instance.indexPage.equals("O")) {
      visible = "true";
    }

    if(instance.jobKindCd.indexOf("03") != 0){
      visible = "false";
    }

    String uiStyle = "{                                                                                                                             " +
                     "  'required-input': {                                                                                                         " +
                     "    'border': {                                                                                                               " +
                     "      'visible': 'false',                                                                                                     " +
                     "      'color': {                                                                                                              " +
                     "        'b': 0,                                                                                                               " +
                     "        'g': 0,                                                                                                               " +
                     "        'r': 225,                                                                                                             " +
                     "        'a': 120                                                                                                              " +
                     "      },                                                                                                                      " +
                     "      'width': 2                                                                                                              " +
                     "    },                                                                                                                        " +
                     "    'background': {                                                                                                           " +
                     "      'visible': 'true',                                                                                                      " +
                     "      'color': {                                                                                                              " +
                     "        'b': 0,                                                                                                               " +
                     "        'g': 0,                                                                                                               " +
                     "        'r': 225,                                                                                                             " +
                     "        'a': 120                                                                                                              " +
                     "      }                                                                                                                       " +
                     "    }                                                                                                                         " +
                     "  },                                                                                                                          " +
                     "  'toast-message': {                                                                                                          " +
                     "    'signature-missing-data': {                                                                                               " +
                     "      'text': '" + mContext.getString(R.string.emptySign) + "'                                                                " +
                     "    }                                                                                                                         " +
                     "  },                                                                                                                          " +
                     "  'toolbar': {                                                                                                                " +
                     "    'buttons': {                                                                                                              " +
                     "      'record': {                                                                                                             " +
                     "        'visible': 'false'                                                                                                    " +
                     "      },                                                                                                                      " +
                     "      'information': {                                                                                                        " +
                     "        'visible': 'true'                                                                                                     " +
                     "      },                                                                                                                      " +
                     "      'tempsave2': {                                                                                                          " +
                     "        'visible': '" + visible + "',                                                                                                    " +
                     "        'enabled': 'true',                                                                                                    " +
                     "        'text': '" + mContext.getString(R.string.confirmSave) + "'                                                            " +
                     "      },                                                                                                                      " +
                     "      'tempsave': {                                                                                                           " +
                     "        'visible': 'true',                                                                                                    " +
                     "        'enabled': 'true',                                                                                                    " +
                     "        'text': '" + mContext.getString(R.string.tempList) + "'                                                               " +
                     "      },                                                                                                                      " +
                     "      'save': {                                                                                                               " +
                     "        'visible': 'true',                                                                                                    " +
                     "        'enabled': 'true',                                                                                                    " +
                     "        'text': '" + mContext.getString(R.string.certifySave) + "'                                                            " +
                     "      },                                                                                                                      " +
                     "      'exit': {                                                                                                               " +
                     "        'visible': 'true',                                                                                                    " +
                     "        'text': '" + mContext.getString(R.string.exit) + "'                                                                   " +
                     "      },                                                                                                                      " +
                     "      'pageattach': {                                                                                                         " +
                     "        'visible': 'true'                                                                                                     " +
                     "      },                                                                                                                      " +
                     "      'page-number': {                                                                                                        " +
                     "        'current': {                                                                                                          " +
                     "          'text-color': {                                                                                                     " +
                     "            'b': 116,                                                                                                         " +
                     "            'g': 186,                                                                                                         " +
                     "            'r': 14,                                                                                                          " +
                     "            'a': 255                                                                                                          " +
                     "          }                                                                                                                   " +
                     "        }                                                                                                                     " +
                     "      }                                                                                                                       " +
                     "    },                                                                                                                        " +
                     "    'move-next': {                                                                                                            " +
                     "      'buttons': {                                                                                                            " +
                     "        'save-move': {                                                                                                        " +
                     "          'text': '" + String.format(mContext.getString(R.string.saveNext), mContext.getString(R.string.certifySave)) + "',   " +
                     "          'visible': true,                                                                                                    " +
                     "          'enabled': true                                                                                                     " +
                     "        },                                                                                                                    " +
                     "        'tempsave-move': {                                                                                                    " +
                     "          'text': '" + String.format(mContext.getString(R.string.saveNext), mContext.getString(R.string.tempList)) + "',      " +
                     "          'visible': true,                                                                                                    " +
                     "          'enabled': true                                                                                                     " +
                     "        },                                                                                                                    " +
                     "        'tempsave2-move': {                                                                                                   " +
                     "          'text': '" + String.format(mContext.getString(R.string.saveNext), mContext.getString(R.string.confirmSave)) + "',   " +
                     "          'visible': true,                                                                                                    " +
                     "          'enabled': true                                                                                                     " +
                     "        },                                                                                                                    " +
                     "        'move': {                                                                                                             " +
                     "          'text': '"+ mContext.getString(R.string.notSaveNext) +"',                                                           " +
                     "          'visible': true,                                                                                                    " +
                     "          'enabled': true                                                                                                     " +
                     "        }                                                                                                                     " +
                     "      }                                                                                                                       " +
                     "    }                                                                                                                         " +
                     "  },                                                                                                                          " +
                     "  'dialog': {                                                                                                                 " +
                     "    'save': {                                                                                                                 " +
                     "      'title': '" + mContext.getString(R.string.certifySave) + "',                                                            " +
                     "      'contents': '" + String.format(mContext.getString(R.string.saveAction), mContext.getString(R.string.certifySave)) + "'  " +
                     "    },                                                                                                                        " +
                     "    'temp-save': {                                                                                                            " +
                     "      'title': '" + mContext.getString(R.string.tempList) + "',                                                               " +
                     "      'contents': '" + String.format(mContext.getString(R.string.saveAction), mContext.getString(R.string.tempList)) + "'     " +
                     "    },                                                                                                                        " +
                     "    'temp-save2': {                                                                                                           " +
                     "      'title': '" + mContext.getString(R.string.confirmSave) + "',                                                            " +
                     "      'contents': '" + String.format(mContext.getString(R.string.saveAction), mContext.getString(R.string.confirmSave)) + "'  " +
                     "    }                                             " +
                     "  }                                               " +
                     "}                                                 ";
    return uiStyle;
  }
}
