/**
   * This method creates a List of DisplaySectionBeans, returning them in the order that the
   * sections appear in a CRF. This List is "lazily" initialized the first time it is requested.
   *
   * @return A List of DisplaySectionBeans.
   * @see org.akaza.openclinica.control.managestudy.PrintCRFServlet
   * @see org.akaza.openclinica.control.managestudy.PrintDataEntryServlet
   */
  public List<DisplaySectionBean> getDisplaySectionBeans() {
    FormBeanUtil formBeanUtil;
    ViewPersistanceHandler persistanceHandler;
    ArrayList<SectionBean> allCrfSections;
    // DAO classes for getting item definitions
    SectionDAO sectionDao;
    CRFVersionDAO crfVersionDao;

    if (displaySectionBeans == null) {
      displaySectionBeans = new ArrayList<DisplaySectionBean>();
      formBeanUtil = new FormBeanUtil();
      if (hasStoredData) persistanceHandler = new ViewPersistanceHandler();

      // We need a CRF version id to populate the form display
      if (this.crfVersionId == 0) {
        return displaySectionBeans;
      }

      sectionDao = new SectionDAO(dataSource);
      allCrfSections = (ArrayList) sectionDao.findByVersionId(this.crfVersionId);

      // for the purposes of null values, try to obtain a valid
      // eventCrfDefinition id
      EventDefinitionCRFBean eventDefBean = null;
      EventCRFBean eventCRFBean = new EventCRFBean();
      if (eventCRFId > 0) {
        EventCRFDAO ecdao = new EventCRFDAO(dataSource);
        eventCRFBean = (EventCRFBean) ecdao.findByPK(eventCRFId);
        StudyEventDAO sedao = new StudyEventDAO(dataSource);
        StudyEventBean studyEvent = (StudyEventBean) sedao.findByPK(eventCRFBean.getStudyEventId());

        EventDefinitionCRFDAO eventDefinitionCRFDAO = new EventDefinitionCRFDAO(dataSource);
        StudyDAO sdao = new StudyDAO(dataSource);
        StudyBean study = sdao.findByStudySubjectId(eventCRFBean.getStudySubjectId());
        eventDefBean =
            eventDefinitionCRFDAO.findByStudyEventIdAndCRFVersionId(
                study, studyEvent.getId(), this.crfVersionId);
      }
      eventDefBean = eventDefBean == null ? new EventDefinitionCRFBean() : eventDefBean;
      // Create an array or List of DisplaySectionBeans representing each
      // section
      // for printing
      DisplaySectionBean displaySectionBean;
      for (SectionBean sectionBean : allCrfSections) {
        displaySectionBean =
            formBeanUtil.createDisplaySectionBWithFormGroups(
                sectionBean.getId(),
                this.crfVersionId,
                dataSource,
                eventDefBean.getId(),
                eventCRFBean,
                context);
        displaySectionBeans.add(displaySectionBean);
      }
    }
    return displaySectionBeans;
  }
  /*
   * Purpose: Iterates over ODM to populate 2 objects: 1. importCRFList: A List of EventCRFs and information on how to
   * process them. 2. importCRFMap: A Map multi-layer map of Subject/Event/Form only populated when the subsequent
   * EventCRF passes the UpsertOn rules.
   */
  public ImportCRFInfoContainer(ODMContainer odmContainer, DataSource ds) {
    importCRFList = new ArrayList<ImportCRFInfo>();

    ArrayList<EventCRFBean> eventCRFBeans = new ArrayList<EventCRFBean>();
    ArrayList<Integer> eventCRFBeanIds = new ArrayList<Integer>();
    EventCRFDAO eventCrfDAO = new EventCRFDAO(ds);
    StudySubjectDAO studySubjectDAO = new StudySubjectDAO(ds);
    StudyEventDefinitionDAO studyEventDefinitionDAO = new StudyEventDefinitionDAO(ds);
    StudyDAO studyDAO = new StudyDAO(ds);
    StudyEventDAO studyEventDAO = new StudyEventDAO(ds);
    UpsertOnBean upsert = odmContainer.getCrfDataPostImportContainer().getUpsertOn();
    // If Upsert bean is not present, create one with default settings
    if (upsert == null) upsert = new UpsertOnBean();
    String studyOID = odmContainer.getCrfDataPostImportContainer().getStudyOID();
    StudyBean studyBean = studyDAO.findByOid(studyOID);
    ArrayList<SubjectDataBean> subjectDataBeans =
        odmContainer.getCrfDataPostImportContainer().getSubjectData();

    Map<String, Map<String, Map<String, String>>> subjectMap =
        new HashMap<String, Map<String, Map<String, String>>>();
    for (SubjectDataBean subjectDataBean : subjectDataBeans) {
      ArrayList<StudyEventDataBean> studyEventDataBeans = subjectDataBean.getStudyEventData();
      StudySubjectBean studySubjectBean =
          studySubjectDAO.findByOidAndStudy(subjectDataBean.getSubjectOID(), studyBean.getId());

      Map<String, Map<String, String>> eventMap = new HashMap<String, Map<String, String>>();
      for (StudyEventDataBean studyEventDataBean : studyEventDataBeans) {
        ArrayList<FormDataBean> formDataBeans = studyEventDataBean.getFormData();
        String sampleOrdinal =
            studyEventDataBean.getStudyEventRepeatKey() == null
                ? "1"
                : studyEventDataBean.getStudyEventRepeatKey();

        StudyEventDefinitionBean studyEventDefinitionBean =
            studyEventDefinitionDAO.findByOidAndStudy(
                studyEventDataBean.getStudyEventOID(),
                studyBean.getId(),
                studyBean.getParentStudyId());
        logger.info(
            "find all by def and subject "
                + studyEventDefinitionBean.getName()
                + " study subject "
                + studySubjectBean.getName());

        StudyEventBean studyEventBean =
            (StudyEventBean)
                studyEventDAO.findByStudySubjectIdAndDefinitionIdAndOrdinal(
                    studySubjectBean.getId(),
                    studyEventDefinitionBean.getId(),
                    Integer.parseInt(sampleOrdinal));
        // @pgawade 16-March-2011 Do not allow the data import
        // if event status is one of the - stopped, signed,
        // locked
        Map<String, String> formMap = new HashMap<String, String>();
        for (FormDataBean formDataBean : formDataBeans) {

          CRFVersionDAO crfVersionDAO = new CRFVersionDAO(ds);
          ArrayList<CRFVersionBean> crfVersionBeans =
              crfVersionDAO.findAllByOid(formDataBean.getFormOID());
          for (CRFVersionBean crfVersionBean : crfVersionBeans) {

            ArrayList<EventCRFBean> eventCrfBeans =
                eventCrfDAO.findByEventSubjectVersion(
                    studyEventBean, studySubjectBean, crfVersionBean);
            // what if we have begun with creating a study
            // event, but haven't entered data yet? this would
            // have us with a study event, but no corresponding
            // event crf, yet.
            if (eventCrfBeans.isEmpty()) {
              logger.debug(
                  "   found no event crfs from Study Event id "
                      + studyEventBean.getId()
                      + ", location "
                      + studyEventBean.getLocation());

              ImportCRFInfo importCrfInfo =
                  new ImportCRFInfo(
                      studyOID,
                      subjectDataBean.getSubjectOID(),
                      studyEventDataBean.getStudyEventOID(),
                      formDataBean.getFormOID());
              importCrfInfo.setPreImportStage(DataEntryStage.UNCOMPLETED);
              String crfStatus = formDataBean.getEventCRFStatus();
              if (crfStatus != null
                  && crfStatus.equals(DataEntryStage.INITIAL_DATA_ENTRY.getName()))
                importCrfInfo.setPostImportStage(DataEntryStage.INITIAL_DATA_ENTRY);
              if ((studyEventBean.getSubjectEventStatus().equals(SubjectEventStatus.SCHEDULED)
                  || studyEventBean
                      .getSubjectEventStatus()
                      .equals(SubjectEventStatus.DATA_ENTRY_STARTED)
                  || studyEventBean.getSubjectEventStatus().equals(SubjectEventStatus.COMPLETED))) {

                if (!upsert.isNotStarted()) {
                  importCrfInfo.setProcessImport(false);
                  importCrfInfo.setEventCRFID(null);
                }
              }
              importCRFList.add(importCrfInfo);
              if (importCrfInfo.isProcessImport()) formMap.put(formDataBean.getFormOID(), "true");
            }

            for (EventCRFBean ecb : eventCrfBeans) {
              ImportCRFInfo importCrfInfo =
                  new ImportCRFInfo(
                      studyOID,
                      subjectDataBean.getSubjectOID(),
                      studyEventDataBean.getStudyEventOID(),
                      formDataBean.getFormOID());
              importCrfInfo.setPreImportStage(ecb.getStage());
              String crfStatus = formDataBean.getEventCRFStatus();
              if (crfStatus != null
                  && crfStatus.equals(DataEntryStage.INITIAL_DATA_ENTRY.getName()))
                importCrfInfo.setPostImportStage(DataEntryStage.INITIAL_DATA_ENTRY);
              importCrfInfo.setEventCRFID(new Integer(ecb.getId()));
              if (!(ecb.getStage().equals(DataEntryStage.INITIAL_DATA_ENTRY)
                      && upsert.isDataEntryStarted())
                  && !(ecb.getStage().equals(DataEntryStage.DOUBLE_DATA_ENTRY_COMPLETE)
                      && upsert.isDataEntryComplete())) importCrfInfo.setProcessImport(false);
              importCRFList.add(importCrfInfo);
              if (importCrfInfo.isProcessImport()) formMap.put(formDataBean.getFormOID(), "true");
            }
          }
        } // formdata loop
        if (formMap.size() > 0) eventMap.put(studyEventDataBean.getStudyEventOID(), formMap);
      } // study event loop
      if (eventMap.size() > 0) subjectMap.put(subjectDataBean.getSubjectOID(), eventMap);
    } // subject data loop
    importCRFMap = subjectMap;
  }
  @Override
  protected void processRequest() throws Exception {
    checkStudyLocked(Page.LIST_STUDY_SUBJECTS, respage.getString("current_study_locked"));
    panel.setStudyInfoShown(false);
    fp = new FormProcessor(request);
    FormDiscrepancyNotes discNotes = null;
    int studySubjectId = fp.getInt(INPUT_STUDY_SUBJECT_ID_FROM_VIEWSUBJECT);
    // input from manage subject matrix, user has specified definition id
    int studyEventDefinitionId = fp.getInt(INPUT_STUDY_EVENT_DEFINITION);

    // TODO: make this sensitive to permissions
    StudySubjectDAO sdao = new StudySubjectDAO(sm.getDataSource());
    StudySubjectBean ssb;
    if (studySubjectId <= 0) {
      ssb = (StudySubjectBean) request.getAttribute(INPUT_STUDY_SUBJECT);
    } else {
      // YW 11-08-2007, << a new study event could not be added if its
      // study subject has been removed
      ssb = (StudySubjectBean) sdao.findByPK(studySubjectId);
      Status s = ssb.getStatus();
      if ("removed".equalsIgnoreCase(s.getName()) || "auto-removed".equalsIgnoreCase(s.getName())) {
        addPageMessage(
            resword.getString("study_event")
                + resterm.getString("could_not_be")
                + resterm.getString("added")
                + "."
                + respage.getString("study_subject_has_been_deleted"));
        request.setAttribute("id", new Integer(studySubjectId).toString());
        forwardPage(Page.VIEW_STUDY_SUBJECT_SERVLET);
      }
      // YW >>
      request.setAttribute(INPUT_REQUEST_STUDY_SUBJECT, "no");
    }

    // running this crashes the server, or so we think...instead, let's grab a count
    // or remove it altogether tbh 10/2009
    // ArrayList subjects = sdao.findAllActiveByStudyOrderByLabel(currentStudy);

    // TODO: make this sensitive to permissions
    StudyEventDefinitionDAO seddao = new StudyEventDefinitionDAO(sm.getDataSource());

    StudyBean studyWithEventDefinitions = currentStudy;
    if (currentStudy.getParentStudyId() > 0) {
      studyWithEventDefinitions = new StudyBean();
      studyWithEventDefinitions.setId(currentStudy.getParentStudyId());
    }
    // find all active definitions with CRFs
    ArrayList eventDefinitions = seddao.findAllActiveByStudy(studyWithEventDefinitions);
    // EventDefinitionCRFDAO edcdao = new
    // EventDefinitionCRFDAO(sm.getDataSource());
    // ArrayList definitionsWithCRF = new ArrayList();
    // for (int i=0; i<eventDefinitions.size(); i++) {
    // StudyEventDefinitionBean sed =
    // (StudyEventDefinitionBean)eventDefinitions.get(i);
    // logger.info("StudyEventDefinition name[" + sed.getName() + "]");
    // ArrayList edcs = edcdao.findAllByEventDefinitionId(sed.getId());
    // if (!edcs.isEmpty()) {
    // definitionsWithCRF.add(sed);
    // }
    // }

    // Collections.sort(definitionsWithCRF);
    Collections.sort(eventDefinitions);

    /*
     * ArrayList eventDefinitionsScheduled = new ArrayList(); for (int i =
     * 0; i < eventDefinitions.size(); i++) { StudyEventDefinitionBean sed =
     * (StudyEventDefinitionBean) eventDefinitions.get(i); if
     * (sed.getType().equalsIgnoreCase("scheduled")) {
     * eventDefinitionsScheduled.add(sed); } }
     */
    // all definitions will appear in scheduled event creation box-11/26/05
    ArrayList eventDefinitionsScheduled = eventDefinitions;

    if (!fp.isSubmitted()) {
      // StudyEventDAO sed = new StudyEventDAO(sm.getDataSource());
      // sed.updateSampleOrdinals_v092();

      HashMap presetValues = new HashMap();

      // YW 08-16-2007 << set default as blank for time
      presetValues.put(INPUT_STARTDATE_PREFIX + "Hour", new Integer(-1));
      presetValues.put(INPUT_STARTDATE_PREFIX + "Minute", new Integer(-1));
      presetValues.put(INPUT_STARTDATE_PREFIX + "Half", new String(""));
      presetValues.put(INPUT_ENDDATE_PREFIX + "Hour", new Integer(-1));
      presetValues.put(INPUT_ENDDATE_PREFIX + "Minute", new Integer(-1));
      presetValues.put(INPUT_ENDDATE_PREFIX + "Half", new String(""));
      for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
        presetValues.put(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Hour", new Integer(-1));
        presetValues.put(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Minute", new Integer(-1));
        presetValues.put(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Half", new String(""));
        presetValues.put(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Hour", new Integer(-1));
        presetValues.put(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Minute", new Integer(-1));
        presetValues.put(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Half", new String(""));
      }

      // SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy");
      // example of taking the above line and transferring to i18n on the
      // below line, tbh
      String dateValue = local_df.format(new Date(System.currentTimeMillis()));
      presetValues.put(INPUT_STARTDATE_PREFIX + "Date", dateValue);
      for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
        presetValues.put(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Date", dateValue);
        // location
        presetValues.put(INPUT_SCHEDULED_LOCATION[i], currentStudy.getFacilityCity());
        presetValues.put(this.DISPLAY_SCHEDULED[i], "none");
      }
      presetValues.put(INPUT_LOCATION, currentStudy.getFacilityCity()); // defualt

      if (ssb != null && ssb.isActive()) {
        presetValues.put(INPUT_STUDY_SUBJECT, ssb);

        String requestStudySubject = (String) request.getAttribute(INPUT_REQUEST_STUDY_SUBJECT);
        if (requestStudySubject != null) {
          presetValues.put(INPUT_REQUEST_STUDY_SUBJECT, requestStudySubject);

          dateValue = local_df.format(new Date());
          presetValues.put(INPUT_STARTDATE_PREFIX + "Date", dateValue);
        }
      }

      if (studyEventDefinitionId > 0) {
        StudyEventDefinitionBean sed =
            (StudyEventDefinitionBean) seddao.findByPK(studyEventDefinitionId);
        presetValues.put(INPUT_STUDY_EVENT_DEFINITION, sed);
      }

      // tbh
      logger.info("set preset values: " + presetValues.toString());
      System.out.println("set preset values: " + presetValues.toString());
      logger.info("found def.w.CRF list, size " + eventDefinitions.size());
      // tbh
      setPresetValues(presetValues);

      ArrayList subjects = new ArrayList();
      setupBeans(subjects, eventDefinitions);

      discNotes = new FormDiscrepancyNotes();
      session.setAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME, discNotes);

      request.setAttribute("eventDefinitionsScheduled", eventDefinitionsScheduled);
      setInputMessages(new HashMap());
      forwardPage(Page.CREATE_NEW_STUDY_EVENT);
    } else {
      // tbh
      // String dateCheck = (String)request.getAttribute("startDate");
      // String endCheck = (String)request.getAttribute("endDate");
      // logger.info(dateCheck+"; "+endCheck);

      String dateCheck2 = request.getParameter("startDate");
      String endCheck2 = request.getParameter("endDate");
      logger.info(dateCheck2 + "; " + endCheck2);

      // YW, 3-12-2008, 2220 fix <<
      String strEnd = fp.getDateTimeInputString(INPUT_ENDDATE_PREFIX);
      String strEndScheduled[] = new String[ADDITIONAL_SCHEDULED_NUM];
      for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
        strEndScheduled[i] = fp.getDateTimeInputString(INPUT_ENDDATE_PREFIX_SCHEDULED[i]);
      }
      Date start = getInputStartDate();
      Date end = null;
      Date[] startScheduled = new Date[ADDITIONAL_SCHEDULED_NUM];
      for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
        startScheduled[i] = getInputStartDateScheduled(i);
      }
      Date[] endScheduled = new Date[ADDITIONAL_SCHEDULED_NUM];

      // YW >>

      // for (java.util.Enumeration enu = request.getAttributeNames();
      // enu.hasMoreElements() ;) {
      // logger.info(">>> found "+enu.nextElement().toString());
      // }
      // tbh
      discNotes =
          (FormDiscrepancyNotes)
              session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
      if (discNotes == null) {
        discNotes = new FormDiscrepancyNotes();
        session.setAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME, discNotes);
      }
      DiscrepancyValidator v = new DiscrepancyValidator(request, discNotes);

      v.addValidation(INPUT_STARTDATE_PREFIX, Validator.IS_DATE_TIME);
      v.alwaysExecuteLastValidation(INPUT_STARTDATE_PREFIX);
      if (!strEnd.equals("")) {
        v.addValidation(INPUT_ENDDATE_PREFIX, Validator.IS_DATE_TIME);
        v.alwaysExecuteLastValidation(INPUT_ENDDATE_PREFIX);
      }

      v.addValidation(
          INPUT_STUDY_EVENT_DEFINITION,
          Validator.ENTITY_EXISTS_IN_STUDY,
          seddao,
          studyWithEventDefinitions);
      // v.addValidation(INPUT_STUDY_SUBJECT, Validator.ENTITY_EXISTS_IN_STUDY, sdao, currentStudy);
      // removed tbh 11/2009
      v.addValidation(INPUT_LOCATION, Validator.NO_BLANKS);
      v.addValidation(INPUT_STUDY_SUBJECT_LABEL, Validator.NO_BLANKS);
      v.addValidation(
          INPUT_LOCATION,
          Validator.LENGTH_NUMERIC_COMPARISON,
          NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO,
          2000);
      v.alwaysExecuteLastValidation(INPUT_LOCATION);

      boolean hasScheduledEvent = false;
      for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
        if (!StringUtil.isBlank(fp.getString(this.INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i]))) {
          // logger.info("has scheduled definition******");
          v.addValidation(
              this.INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i],
              Validator.ENTITY_EXISTS_IN_STUDY,
              seddao,
              studyWithEventDefinitions);
          v.addValidation(INPUT_SCHEDULED_LOCATION[i], Validator.NO_BLANKS);
          v.addValidation(
              INPUT_SCHEDULED_LOCATION[i],
              Validator.LENGTH_NUMERIC_COMPARISON,
              NumericComparisonOperator.LESS_THAN_OR_EQUAL_TO,
              2000);
          v.alwaysExecuteLastValidation(INPUT_SCHEDULED_LOCATION[i]);
          v.addValidation(INPUT_STARTDATE_PREFIX_SCHEDULED[i], Validator.IS_DATE_TIME);
          v.alwaysExecuteLastValidation(INPUT_STARTDATE_PREFIX_SCHEDULED[i]);
          if (!strEndScheduled[i].equals("")) {
            v.addValidation(INPUT_ENDDATE_PREFIX_SCHEDULED[i], Validator.IS_DATE_TIME);
            v.alwaysExecuteLastValidation(INPUT_ENDDATE_PREFIX_SCHEDULED[i]);
          }
          hasScheduledEvent = true;
          fp.addPresetValue(DISPLAY_SCHEDULED[i], "all");
        } else {
          fp.addPresetValue(DISPLAY_SCHEDULED[i], "none");
        }
      }

      HashMap errors = v.validate();
      // logger.info("v is not null *****");
      String location = resword.getString("location");
      // don't allow user to use the default value 'Location' since
      // location
      // is a required field
      if (!StringUtil.isBlank(fp.getString(INPUT_LOCATION))
          && fp.getString(INPUT_LOCATION).equalsIgnoreCase(location)) {
        Validator.addError(errors, INPUT_LOCATION, restext.getString("not_a_valid_location"));
      }

      StudyEventDefinitionBean definition =
          (StudyEventDefinitionBean) seddao.findByPK(fp.getInt(INPUT_STUDY_EVENT_DEFINITION));

      // StudySubjectBean studySubject = (StudySubjectBean)
      // sdao.findByPK(fp.getInt(INPUT_STUDY_SUBJECT));
      // sdao.findByLabelAndStudy(label, study)
      StudySubjectBean studySubject =
          (StudySubjectBean)
              sdao.findByLabelAndStudy(fp.getString(INPUT_STUDY_SUBJECT_LABEL), currentStudy);
      // >> 4358 tbh, 11/2009
      // what if we are sent here from AddNewSubjectServlet.java??? we need to get that study
      // subject bean
      if (request.getAttribute(INPUT_STUDY_SUBJECT) != null) {
        studySubject = (StudySubjectBean) request.getAttribute(INPUT_STUDY_SUBJECT);
      }
      // << tbh
      if (studySubject.getLabel() == "") {
        // add an error here, tbh
        System.out.println("tripped the error here 20091109");
        Validator.addError(
            errors,
            INPUT_STUDY_SUBJECT,
            respage.getString("must_enter_subject_ID_for_identifying"));
      }

      if (!subjectMayReceiveStudyEvent(sm.getDataSource(), definition, studySubject)) {
        Validator.addError(
            errors,
            INPUT_STUDY_EVENT_DEFINITION,
            restext.getString("not_added_since_event_not_repeating"));
      }

      ArrayList<StudyEventDefinitionBean> definitionScheduleds =
          new ArrayList<StudyEventDefinitionBean>();
      int[] scheduledDefinitionIds = new int[ADDITIONAL_SCHEDULED_NUM];
      if (hasScheduledEvent) {
        for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
          int pk = fp.getInt(INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i]);
          if (pk > 0) {
            StudyEventDefinitionBean sedb = (StudyEventDefinitionBean) seddao.findByPK(pk);
            System.out.println(
                "scheduled def:"
                    + pk
                    + " "
                    + INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i]
                    + " "
                    + sedb.getName());
            definitionScheduleds.add(sedb);
            scheduledDefinitionIds[i] = pk;
            if (!subjectMayReceiveStudyEvent(sm.getDataSource(), sedb, studySubject)) {
              Validator.addError(
                  errors,
                  INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i],
                  restext.getString("not_added_since_event_not_repeating"));
            }
          } else {
            definitionScheduleds.add(new StudyEventDefinitionBean());
          }
        }
      }

      // YW, 3-12-2008, 2220 fix >>
      if (!"".equals(strEnd)
          && !errors.containsKey(INPUT_STARTDATE_PREFIX)
          && !errors.containsKey(INPUT_ENDDATE_PREFIX)) {
        end = getInputEndDate();
        if (!fp.getString(INPUT_STARTDATE_PREFIX + "Date")
            .equals(fp.getString(INPUT_ENDDATE_PREFIX + "Date"))) {
          if (end.before(start)) {
            Validator.addError(
                errors,
                INPUT_ENDDATE_PREFIX,
                resexception.getString("input_provided_not_occure_after_previous_start_date_time"));
          }
        } else {
          // if in same date, only check when both had time entered
          if (fp.timeEntered(INPUT_STARTDATE_PREFIX) && fp.timeEntered(INPUT_ENDDATE_PREFIX)) {
            if (end.before(start) || end.equals(start)) {
              Validator.addError(
                  errors,
                  INPUT_ENDDATE_PREFIX,
                  resexception.getString(
                      "input_provided_not_occure_after_previous_start_date_time"));
            }
          }
        }
      }

      String prevStartPrefix = INPUT_STARTDATE_PREFIX;
      Set<Integer> pickedSeds = new TreeSet<Integer>();
      pickedSeds.add(studyEventDefinitionId);
      HashMap<Integer, Integer> scheduledSeds = new HashMap<Integer, Integer>();
      scheduledSeds.put(studyEventDefinitionId, -1);
      for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
        if (scheduledDefinitionIds[i] > 0
            && !errors.containsKey(INPUT_STARTDATE_PREFIX_SCHEDULED[i])
            && !errors.containsKey(INPUT_ENDDATE_PREFIX_SCHEDULED[i])) {
          if (scheduledSeds.containsKey(scheduledDefinitionIds[i])) {
            int prevStart = scheduledSeds.get(scheduledDefinitionIds[i]);
            prevStartPrefix =
                prevStart == -1
                    ? INPUT_STARTDATE_PREFIX
                    : INPUT_STARTDATE_PREFIX_SCHEDULED[prevStart];
            Date prevStartDate =
                prevStart == -1
                    ? this.getInputStartDate()
                    : this.getInputStartDateScheduled(
                        Integer.parseInt(
                            prevStartPrefix.charAt(prevStartPrefix.length() - 1) + ""));
            if (fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Date")
                .equals(fp.getString(prevStartPrefix + "Date"))) {
              // if in same day, only check when both have time
              // inputs.
              boolean schStartTime = fp.timeEntered(INPUT_STARTDATE_PREFIX_SCHEDULED[i]);
              boolean startTime = fp.timeEntered(prevStartPrefix);
              if (schStartTime && startTime) {
                if (startScheduled[i].before(prevStartDate)) {
                  Validator.addError(
                      errors,
                      INPUT_STARTDATE_PREFIX_SCHEDULED[i],
                      resexception.getString(
                          "input_provided_not_occure_after_previous_start_date_time"));
                }
              }
            } else {
              if (startScheduled[i].before(prevStartDate)) {
                Validator.addError(
                    errors,
                    INPUT_STARTDATE_PREFIX_SCHEDULED[i],
                    resexception.getString(
                        "input_provided_not_occure_after_previous_start_date_time"));
              }
            }
          }
          scheduledSeds.put(scheduledDefinitionIds[i], i);
          if (!strEndScheduled[i].equals("")) {
            endScheduled[i] = fp.getDateTime(INPUT_ENDDATE_PREFIX_SCHEDULED[i]);
            String prevEndPrefix =
                i > 0 ? INPUT_ENDDATE_PREFIX_SCHEDULED[i - 1] : INPUT_ENDDATE_PREFIX;
            if (!fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Date")
                .equals(fp.getString(prevEndPrefix + "Date"))) {
              if (endScheduled[i].before(startScheduled[i])) {
                Validator.addError(
                    errors,
                    INPUT_ENDDATE_PREFIX_SCHEDULED[i],
                    resexception.getString(
                        "input_provided_not_occure_after_previous_start_date_time"));
              }
            } else {
              // if in same date, only check when both had time
              // entered
              if (fp.timeEntered(INPUT_STARTDATE_PREFIX_SCHEDULED[i])
                  && fp.timeEntered(INPUT_ENDDATE_PREFIX_SCHEDULED[i])) {
                if (endScheduled[i].before(startScheduled[i])
                    || endScheduled[i].equals(startScheduled[i])) {
                  Validator.addError(
                      errors,
                      INPUT_ENDDATE_PREFIX_SCHEDULED[i],
                      resexception.getString(
                          "input_provided_not_occure_after_previous_start_date_time"));
                }
              }
            }
          }
        }
      }
      // YW >>
      System.out.println("we have errors; number of this; " + errors.size());
      if (!errors.isEmpty()) {
        logger.info("we have errors; number of this; " + errors.size());
        System.out.println(
            "found request study subject: " + fp.getString(INPUT_REQUEST_STUDY_SUBJECT));
        addPageMessage(respage.getString("errors_in_submission_see_below"));
        setInputMessages(errors);

        fp.addPresetValue(INPUT_STUDY_EVENT_DEFINITION, definition);
        fp.addPresetValue(INPUT_STUDY_SUBJECT, studySubject);
        fp.addPresetValue(INPUT_STUDY_SUBJECT_LABEL, fp.getString(INPUT_STUDY_SUBJECT_LABEL));
        fp.addPresetValue(INPUT_REQUEST_STUDY_SUBJECT, fp.getString(INPUT_REQUEST_STUDY_SUBJECT));
        fp.addPresetValue(INPUT_LOCATION, fp.getString(INPUT_LOCATION));

        for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
          fp.addPresetValue(INPUT_SCHEDULED_LOCATION[i], fp.getString(INPUT_SCHEDULED_LOCATION[i]));
        }
        String prefixes[] = new String[2 + 2 * ADDITIONAL_SCHEDULED_NUM];
        prefixes[0] = INPUT_STARTDATE_PREFIX;
        prefixes[1] = INPUT_ENDDATE_PREFIX;
        int b = ADDITIONAL_SCHEDULED_NUM + 2;
        for (int i = 2; i < b; ++i) {
          prefixes[i] = INPUT_STARTDATE_PREFIX_SCHEDULED[i - 2];
        }
        for (int i = b; i < ADDITIONAL_SCHEDULED_NUM + b; ++i) {
          prefixes[i] = INPUT_ENDDATE_PREFIX_SCHEDULED[i - b];
        }
        fp.setCurrentDateTimeValuesAsPreset(prefixes);

        if (hasScheduledEvent) {
          for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
            fp.addPresetValue(
                INPUT_STUDY_EVENT_DEFINITION_SCHEDULED[i], definitionScheduleds.get(i));
          }
        }

        setPresetValues(fp.getPresetValues());
        ArrayList subjects = new ArrayList();
        setupBeans(subjects, eventDefinitions);
        request.setAttribute("eventDefinitionsScheduled", eventDefinitionsScheduled);
        forwardPage(Page.CREATE_NEW_STUDY_EVENT);
      } else {
        System.out.println("error is empty");
        StudyEventDAO sed = new StudyEventDAO(sm.getDataSource());

        StudyEventBean studyEvent = new StudyEventBean();
        studyEvent.setStudyEventDefinitionId(definition.getId());
        studyEvent.setStudySubjectId(studySubject.getId());

        // YW 08-17-2007 <<
        if ("-1".equals(getInputStartHour())
            && "-1".equals(getInputStartMinute())
            && "".equals(getInputStartHalf())) {
          studyEvent.setStartTimeFlag(false);
        } else {
          studyEvent.setStartTimeFlag(true);
        }
        // YW >>
        studyEvent.setDateStarted(start);
        // comment to find bug 1389, tbh
        logger.info("found start date: " + local_df.format(start));
        Date startScheduled2[] = new Date[ADDITIONAL_SCHEDULED_NUM];
        for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {
          startScheduled2[i] = getInputStartDateScheduled(i);
        }
        // tbh
        // YW, 3-12-2008, 2220 fix <<
        if (!"".equals(strEnd)) {
          // YW >>
          if ("-1".equals(getInputEndHour())
              && "-1".equals(getInputEndMinute())
              && "".equals(getInputEndHalf())) {
            studyEvent.setEndTimeFlag(false);
          } else {
            studyEvent.setEndTimeFlag(true);
          }
          studyEvent.setDateEnded(end);
        }
        studyEvent.setOwner(ub);
        studyEvent.setStatus(Status.AVAILABLE);
        studyEvent.setLocation(fp.getString(INPUT_LOCATION));
        studyEvent.setSubjectEventStatus(SubjectEventStatus.SCHEDULED);

        // ArrayList subjectsExistingEvents =
        // sed.findAllByStudyAndStudySubjectId(currentStudy,
        // studySubject.getId());
        studyEvent.setSampleOrdinal(sed.getMaxSampleOrdinal(definition, studySubject) + 1);

        studyEvent = (StudyEventBean) sed.create(studyEvent);

        if (!studyEvent.isActive()) {
          throw new OpenClinicaException(restext.getString("event_not_created_in_database"), "2");
        }
        addPageMessage(
            restext.getString("X_event_wiht_definition")
                + definition.getName()
                + restext.getString("X_and_subject")
                + studySubject.getName()
                + respage.getString("X_was_created_succesfully"));

        // save discrepancy notes into DB
        FormDiscrepancyNotes fdn =
            (FormDiscrepancyNotes)
                session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
        DiscrepancyNoteDAO dndao = new DiscrepancyNoteDAO(sm.getDataSource());
        String[] eventFields = {INPUT_LOCATION, INPUT_STARTDATE_PREFIX, INPUT_ENDDATE_PREFIX};
        for (String element : eventFields) {
          AddNewSubjectServlet.saveFieldNotes(
              element, fdn, dndao, studyEvent.getId(), "studyEvent", currentStudy);
        }
        // logger.info("here ok 3333333333333333");
        if (hasScheduledEvent) {
          for (int i = 0; i < ADDITIONAL_SCHEDULED_NUM; ++i) {

            // should only do the following process if user inputs a
            // scheduled event,
            // which is scheduledDefinitionIds[i] > 0
            if (scheduledDefinitionIds[i] > 0) {
              if (subjectMayReceiveStudyEvent(
                  sm.getDataSource(), definitionScheduleds.get(i), studySubject)) {

                StudyEventBean studyEventScheduled = new StudyEventBean();
                studyEventScheduled.setStudyEventDefinitionId(scheduledDefinitionIds[i]);
                studyEventScheduled.setStudySubjectId(studySubject.getId());

                // YW 11-14-2007
                if ("-1".equals(fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Hour"))
                    && "-1".equals(fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Minute"))
                    && "".equals(fp.getString(INPUT_STARTDATE_PREFIX_SCHEDULED[i] + "Half"))) {
                  studyEventScheduled.setStartTimeFlag(false);
                } else {
                  studyEventScheduled.setStartTimeFlag(true);
                }
                // YW >>

                studyEventScheduled.setDateStarted(startScheduled[i]);
                // YW, 3-12-2008, 2220 fix<<
                if (!"".equals(strEndScheduled[i])) {
                  endScheduled[i] = fp.getDateTime(INPUT_ENDDATE_PREFIX_SCHEDULED[i]);
                  if ("-1".equals(fp.getString(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Hour"))
                      && "-1".equals(fp.getString(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Minute"))
                      && "".equals(fp.getString(INPUT_ENDDATE_PREFIX_SCHEDULED[i] + "Half"))) {
                    studyEventScheduled.setEndTimeFlag(false);
                  } else {
                    studyEventScheduled.setEndTimeFlag(true);
                  }
                }
                studyEventScheduled.setDateEnded(endScheduled[i]);
                // YW >>
                studyEventScheduled.setOwner(ub);
                studyEventScheduled.setStatus(Status.AVAILABLE);
                studyEventScheduled.setLocation(fp.getString(INPUT_SCHEDULED_LOCATION[i]));
                studyEvent.setSubjectEventStatus(SubjectEventStatus.SCHEDULED);

                // subjectsExistingEvents =
                // sed.findAllByStudyAndStudySubjectId(
                // currentStudy,
                // studySubject.getId());
                studyEventScheduled.setSampleOrdinal(
                    sed.getMaxSampleOrdinal(definitionScheduleds.get(i), studySubject) + 1);
                // System.out.println("create scheduled events");
                studyEventScheduled = (StudyEventBean) sed.create(studyEventScheduled);
                if (!studyEventScheduled.isActive()) {
                  throw new OpenClinicaException(
                      restext.getString("scheduled_event_not_created_in_database"), "2");
                }

                AddNewSubjectServlet.saveFieldNotes(
                    INPUT_SCHEDULED_LOCATION[i],
                    fdn,
                    dndao,
                    studyEventScheduled.getId(),
                    "studyEvent",
                    currentStudy);
                // YW 3-12-2008, 2220 fix <<
                AddNewSubjectServlet.saveFieldNotes(
                    INPUT_STARTDATE_PREFIX_SCHEDULED[i],
                    fdn,
                    dndao,
                    studyEventScheduled.getId(),
                    "studyEvent",
                    currentStudy);
                AddNewSubjectServlet.saveFieldNotes(
                    INPUT_ENDDATE_PREFIX_SCHEDULED[i],
                    fdn,
                    dndao,
                    studyEventScheduled.getId(),
                    "studyEvent",
                    currentStudy);
                // YW >>
              } else {
                addPageMessage(
                    restext.getString("scheduled_event_definition")
                        + definitionScheduleds.get(i).getName()
                        + restext.getString("X_and_subject")
                        + studySubject.getName()
                        + restext.getString("not_created_since_event_not_repeating")
                        + restext.getString("event_type_already_exists"));
              }
            }
          }
        } // if

        session.removeAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
        request.setAttribute(
            EnterDataForStudyEventServlet.INPUT_EVENT_ID, String.valueOf(studyEvent.getId()));
        response.encodeRedirectURL("EnterDataForStudyEvent?eventId=" + studyEvent.getId());
        forwardPage(Page.ENTER_DATA_FOR_STUDY_EVENT_SERVLET);
        // we want to actually have url of entering data in browser, so
        // redirecting
        // response.sendRedirect(response.encodeRedirectURL(
        // "EnterDataForStudyEvent?eventId="
        // + studyEvent.getId()));
        return;
      }
    }
  }