/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * file: timetest.c
 * description: test time and date routines
 */
/***********************************************************************
** Includes
***********************************************************************/
/* Used to get the command line option */
#include "plgetopt.h"

#include "prinit.h"
#include "prtime.h"
#include "prprf.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int failed_already = 0;
PRBool debug_mode = PR_FALSE;

static char* dayOfWeek[] = {"Sun", "Mon", "Tue", "Wed",
                            "Thu", "Fri", "Sat", "???"};
static char* month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
                        "Aug", "Sep", "Oct", "Nov", "Dec", "???"};

static void PrintExplodedTime(const PRExplodedTime* et) {
  PRInt32 totalOffset;
  PRInt32 hourOffset, minOffset;
  const char* sign;

  /* Print day of the week, month, day, hour, minute, and second */
  if (debug_mode)
    printf("%s %s %ld %02ld:%02ld:%02ld ", dayOfWeek[et->tm_wday],
           month[et->tm_month], et->tm_mday, et->tm_hour, et->tm_min,
           et->tm_sec);

  /* Print time zone */
  totalOffset = et->tm_params.tp_gmt_offset + et->tm_params.tp_dst_offset;
  if (totalOffset == 0) {
    if (debug_mode) {
      printf("UTC ");
    }
  } else {
    sign = "+";
    if (totalOffset < 0) {
      totalOffset = -totalOffset;
      sign = "-";
    }
    hourOffset = totalOffset / 3600;
    minOffset = (totalOffset % 3600) / 60;
    if (debug_mode) {
      printf("%s%02ld%02ld ", sign, hourOffset, minOffset);
    }
  }

  /* Print year */
  if (debug_mode) {
    printf("%hd", et->tm_year);
  }
}

static int ExplodedTimeIsEqual(const PRExplodedTime* et1,
                               const PRExplodedTime* et2) {
  if (et1->tm_usec == et2->tm_usec && et1->tm_sec == et2->tm_sec &&
      et1->tm_min == et2->tm_min && et1->tm_hour == et2->tm_hour &&
      et1->tm_mday == et2->tm_mday && et1->tm_month == et2->tm_month &&
      et1->tm_year == et2->tm_year && et1->tm_wday == et2->tm_wday &&
      et1->tm_yday == et2->tm_yday &&
      et1->tm_params.tp_gmt_offset == et2->tm_params.tp_gmt_offset &&
      et1->tm_params.tp_dst_offset == et2->tm_params.tp_dst_offset) {
    return 1;
  } else {
    return 0;
  }
}

static void testParseTimeString(PRTime t) {
  PRExplodedTime et;
  PRTime t2;
  char timeString[128];
  char buf[128];
  PRInt32 totalOffset;
  PRInt32 hourOffset, minOffset;
  const char* sign;
  PRInt64 usec_per_sec;

  /* Truncate the microsecond part of PRTime */
  LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
  LL_DIV(t, t, usec_per_sec);
  LL_MUL(t, t, usec_per_sec);

  PR_ExplodeTime(t, PR_LocalTimeParameters, &et);

  /* Print day of the week, month, day, hour, minute, and second */
  PR_snprintf(timeString, 128, "%s %s %ld %02ld:%02ld:%02ld ",
              dayOfWeek[et.tm_wday], month[et.tm_month], et.tm_mday, et.tm_hour,
              et.tm_min, et.tm_sec);
  /* Print time zone */
  totalOffset = et.tm_params.tp_gmt_offset + et.tm_params.tp_dst_offset;
  if (totalOffset == 0) {
    strcat(timeString, "GMT "); /* I wanted to use "UTC" here, but
                                 * PR_ParseTimeString doesn't
                                 * understand "UTC".  */
  } else {
    sign = "+";
    if (totalOffset < 0) {
      totalOffset = -totalOffset;
      sign = "-";
    }
    hourOffset = totalOffset / 3600;
    minOffset = (totalOffset % 3600) / 60;
    PR_snprintf(buf, 128, "%s%02ld%02ld ", sign, hourOffset, minOffset);
    strcat(timeString, buf);
  }
  /* Print year */
  PR_snprintf(buf, 128, "%hd", et.tm_year);
  strcat(timeString, buf);

  if (PR_ParseTimeString(timeString, PR_FALSE, &t2) == PR_FAILURE) {
    fprintf(stderr, "PR_ParseTimeString() failed\n");
    exit(1);
  }
  if (LL_NE(t, t2)) {
    fprintf(stderr, "PR_ParseTimeString() incorrect\n");
    PR_snprintf(buf, 128, "t is %lld, t2 is %lld, time string is %s\n", t, t2,
                timeString);
    fprintf(stderr, "%s\n", buf);
    exit(1);
  }
}

int main(int argc, char** argv) {
  /* The command line argument: -d is used to determine if the test is being run
  in debug mode. The regress tool requires only one line output:PASS or FAIL.
  All of the printfs associated with this test has been handled with a if
  (debug_mode) test. Usage: test_name -d
  */
  PLOptStatus os;
  PLOptState* opt;

  opt = PL_CreateOptState(argc, argv, "d");
  while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) {
    if (PL_OPT_BAD == os) {
      continue;
    }
    switch (opt->option) {
      case 'd': /* debug mode */
        debug_mode = PR_TRUE;
        break;
      default:
        break;
    }
  }
  PL_DestroyOptState(opt);

  /* main test */

  PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);

  /* Testing zero PRTime (the epoch) */
  {
    PRTime t;
    PRExplodedTime et;

    LL_I2L(t, 0);
    if (debug_mode) {
      printf("The NSPR epoch is:\n");
    }
    PR_ExplodeTime(t, PR_LocalTimeParameters, &et);
    PrintExplodedTime(&et);
    if (debug_mode) {
      printf("\n");
    }
    PR_ExplodeTime(t, PR_GMTParameters, &et);
    PrintExplodedTime(&et);
    if (debug_mode) {
      printf("\n\n");
    }
    testParseTimeString(t);
  }

  /*
   *************************************************************
   **
   **  Testing PR_Now(), PR_ExplodeTime, and PR_ImplodeTime
   **  on the current time
   **
   *************************************************************
   */

  {
    PRTime t1, t2;
    PRExplodedTime et;

    if (debug_mode) {
      printf("*********************************************\n");
      printf("**                                         **\n");
      printf("** Testing PR_Now(), PR_ExplodeTime, and   **\n");
      printf("** PR_ImplodeTime on the current time      **\n");
      printf("**                                         **\n");
      printf("*********************************************\n\n");
    }
    t1 = PR_Now();

    /* First try converting to UTC */

    PR_ExplodeTime(t1, PR_GMTParameters, &et);
    if (et.tm_params.tp_gmt_offset || et.tm_params.tp_dst_offset) {
      if (debug_mode) {
        printf("ERROR: UTC has nonzero gmt or dst offset.\n");
      } else {
        failed_already = 1;
      }
      return 1;
    }
    if (debug_mode) {
      printf("Current UTC is ");
    }
    PrintExplodedTime(&et);
    if (debug_mode) {
      printf("\n");
    }

    t2 = PR_ImplodeTime(&et);
    if (LL_NE(t1, t2)) {
      if (debug_mode) {
        printf("ERROR: Explode and implode are NOT inverse.\n");
      } else {
        printf("FAIL\n");
      }
      return 1;
    }

    /* Next, try converting to local (US Pacific) time */

    PR_ExplodeTime(t1, PR_LocalTimeParameters, &et);
    if (debug_mode) {
      printf("Current local time is ");
    }
    PrintExplodedTime(&et);
    if (debug_mode) {
      printf("\n");
    }
    if (debug_mode)
      printf("GMT offset is %ld, DST offset is %ld\n",
             et.tm_params.tp_gmt_offset, et.tm_params.tp_dst_offset);
    t2 = PR_ImplodeTime(&et);
    if (LL_NE(t1, t2)) {
      if (debug_mode) {
        printf("ERROR: Explode and implode are NOT inverse.\n");
      }
      return 1;
    }

    if (debug_mode) {
      printf("Please examine the results\n");
    }
    testParseTimeString(t1);
  }

  /*
   *******************************************
   **
   ** Testing PR_NormalizeTime()
   **
   *******************************************
   */

  /* July 4, 2001 is Wednesday */
  {
    PRExplodedTime et;

    if (debug_mode) {
      printf("\n");
      printf("**********************************\n");
      printf("**                              **\n");
      printf("** Testing PR_NormalizeTime()   **\n");
      printf("**                              **\n");
      printf("**********************************\n\n");
    }
    et.tm_year = 2001;
    et.tm_month = 7 - 1;
    et.tm_mday = 4;
    et.tm_hour = 0;
    et.tm_min = 0;
    et.tm_sec = 0;
    et.tm_usec = 0;
    et.tm_params = PR_GMTParameters(&et);

    PR_NormalizeTime(&et, PR_GMTParameters);

    if (debug_mode) {
      printf("July 4, 2001 is %s.\n", dayOfWeek[et.tm_wday]);
    }
    if (et.tm_wday == 3) {
      if (debug_mode) {
        printf("PASS\n");
      }
    } else {
      if (debug_mode) {
        printf("ERROR: It should be Wednesday\n");
      } else {
        failed_already = 1;
      }
      return 1;
    }
    testParseTimeString(PR_ImplodeTime(&et));

    /* June 12, 1997 23:00 PST == June 13, 1997 00:00 PDT */
    et.tm_year = 1997;
    et.tm_month = 6 - 1;
    et.tm_mday = 12;
    et.tm_hour = 23;
    et.tm_min = 0;
    et.tm_sec = 0;
    et.tm_usec = 0;
    et.tm_params.tp_gmt_offset = -8 * 3600;
    et.tm_params.tp_dst_offset = 0;

    PR_NormalizeTime(&et, PR_USPacificTimeParameters);

    if (debug_mode) {
      printf("Thu Jun 12, 1997 23:00:00 PST is ");
    }
    PrintExplodedTime(&et);
    if (debug_mode) {
      printf(".\n");
    }
    if (et.tm_wday == 5) {
      if (debug_mode) {
        printf("PASS\n");
      }
    } else {
      if (debug_mode) {
        printf("ERROR: It should be Friday\n");
      } else {
        failed_already = 1;
      }
      return 1;
    }
    testParseTimeString(PR_ImplodeTime(&et));

    /* Feb 14, 1997 00:00:00 PDT == Feb 13, 1997 23:00:00 PST */
    et.tm_year = 1997;
    et.tm_month = 2 - 1;
    et.tm_mday = 14;
    et.tm_hour = 0;
    et.tm_min = 0;
    et.tm_sec = 0;
    et.tm_usec = 0;
    et.tm_params.tp_gmt_offset = -8 * 3600;
    et.tm_params.tp_dst_offset = 3600;

    PR_NormalizeTime(&et, PR_USPacificTimeParameters);

    if (debug_mode) {
      printf("Fri Feb 14, 1997 00:00:00 PDT is ");
    }
    PrintExplodedTime(&et);
    if (debug_mode) {
      printf(".\n");
    }
    if (et.tm_wday == 4) {
      if (debug_mode) {
        printf("PASS\n");
      }
    } else {
      if (debug_mode) {
        printf("ERROR: It should be Thursday\n");
      } else {
        failed_already = 1;
      }
      return 1;
    }
    testParseTimeString(PR_ImplodeTime(&et));

    /* What time is Nov. 7, 1996, 18:29:23 PDT? */
    et.tm_year = 1996;
    et.tm_month = 11 - 1;
    et.tm_mday = 7;
    et.tm_hour = 18;
    et.tm_min = 29;
    et.tm_sec = 23;
    et.tm_usec = 0;
    et.tm_params.tp_gmt_offset = -8 * 3600; /* PDT */
    et.tm_params.tp_dst_offset = 3600;

    PR_NormalizeTime(&et, PR_LocalTimeParameters);
    if (debug_mode) {
      printf("Nov 7 18:29:23 PDT 1996 is ");
    }
    PrintExplodedTime(&et);
    if (debug_mode) {
      printf(".\n");
    }
    testParseTimeString(PR_ImplodeTime(&et));

    /* What time is Oct. 7, 1995, 18:29:23 PST? */
    et.tm_year = 1995;
    et.tm_month = 10 - 1;
    et.tm_mday = 7;
    et.tm_hour = 18;
    et.tm_min = 29;
    et.tm_sec = 23;
    et.tm_params.tp_gmt_offset = -8 * 3600; /* PST */
    et.tm_params.tp_dst_offset = 0;

    PR_NormalizeTime(&et, PR_LocalTimeParameters);
    if (debug_mode) {
      printf("Oct 7 18:29:23 PST 1995 is ");
    }
    PrintExplodedTime(&et);
    if (debug_mode) {
      printf(".\n");
    }
    testParseTimeString(PR_ImplodeTime(&et));

    if (debug_mode) {
      printf("Please examine the results\n");
    }
  }

  /*
   **************************************************************
   **
   ** Testing range of years
   **
   **************************************************************
   */

  {
    PRExplodedTime et1, et2;
    PRTime ttt;
    PRTime secs;

    if (debug_mode) {
      printf("\n");
      printf("***************************************\n");
      printf("**                                   **\n");
      printf("**  Testing range of years           **\n");
      printf("**                                   **\n");
      printf("***************************************\n\n");
    }
    /* April 4, 1917 GMT */
    et1.tm_usec = 0;
    et1.tm_sec = 0;
    et1.tm_min = 0;
    et1.tm_hour = 0;
    et1.tm_mday = 4;
    et1.tm_month = 4 - 1;
    et1.tm_year = 1917;
    et1.tm_params = PR_GMTParameters(&et1);
    PR_NormalizeTime(&et1, PR_LocalTimeParameters);
    secs = PR_ImplodeTime(&et1);
    if (LL_GE_ZERO(secs)) {
      if (debug_mode) {
        printf("ERROR: April 4, 1917 GMT returns a nonnegative second count\n");
      }
      failed_already = 1;
      return 1;
    }
    PR_ExplodeTime(secs, PR_LocalTimeParameters, &et2);
    if (!ExplodedTimeIsEqual(&et1, &et2)) {
      if (debug_mode) {
        printf(
            "ERROR: PR_ImplodeTime and PR_ExplodeTime are not inverse for "
            "April 4, 1917 GMT\n");
      }
      failed_already = 1;
      return 1;
    }
    ttt = PR_ImplodeTime(&et1);
    testParseTimeString(ttt);

    if (debug_mode) {
      printf("Test passed for April 4, 1917\n");
    }

    /* July 4, 2050 */
    et1.tm_usec = 0;
    et1.tm_sec = 0;
    et1.tm_min = 0;
    et1.tm_hour = 0;
    et1.tm_mday = 4;
    et1.tm_month = 7 - 1;
    et1.tm_year = 2050;
    et1.tm_params = PR_GMTParameters(&et1);
    PR_NormalizeTime(&et1, PR_LocalTimeParameters);
    secs = PR_ImplodeTime(&et1);
    if (!LL_GE_ZERO(secs)) {
      if (debug_mode) {
        printf("ERROR: July 4, 2050 GMT returns a negative second count\n");
      }
      failed_already = 1;
      return 1;
    }
    PR_ExplodeTime(secs, PR_LocalTimeParameters, &et2);
    if (!ExplodedTimeIsEqual(&et1, &et2)) {
      if (debug_mode) {
        printf(
            "ERROR: PR_ImplodeTime and PR_ExplodeTime are not inverse for July "
            "4, 2050 GMT\n");
      }
      failed_already = 1;
      return 1;
    }
    testParseTimeString(PR_ImplodeTime(&et1));

    if (debug_mode) {
      printf("Test passed for July 4, 2050\n");
    }
  }

  /*
   **************************************************************
   **
   **  Stress test
   *
   **      Go through four years, starting from
   **      00:00:00 PST Jan. 1, 2005, incrementing
   **      every 10 minutes.
   **
   **************************************************************
   */

  {
    PRExplodedTime et, et1, et2;
    PRInt64 usecPer10Min;
    int day, hour, min;
    PRTime usecs;
    int dstInEffect = 0;

    if (debug_mode) {
      printf("\n");
      printf("*******************************************************\n");
      printf("**                                                   **\n");
      printf("**        Stress test  Pacific Time                  **\n");
      printf("**  Starting from midnight Jan. 1, 2005 PST,         **\n");
      printf("**  going through four years in 10-minute increment  **\n");
      printf("**                                                   **\n");
      printf("*******************************************************\n\n");
    }
    LL_I2L(usecPer10Min, 600000000L);

    /* 00:00:00 PST Jan. 1, 2005 */
    et.tm_usec = 0;
    et.tm_sec = 0;
    et.tm_min = 0;
    et.tm_hour = 0;
    et.tm_mday = 1;
    et.tm_month = 0;
    et.tm_year = 2005;
    et.tm_params.tp_gmt_offset = -8 * 3600;
    et.tm_params.tp_dst_offset = 0;
    usecs = PR_ImplodeTime(&et);

    for (day = 0; day < 4 * 365 + 1; day++) {
      for (hour = 0; hour < 24; hour++) {
        for (min = 0; min < 60; min += 10) {
          LL_ADD(usecs, usecs, usecPer10Min);
          PR_ExplodeTime(usecs, PR_USPacificTimeParameters, &et1);

          et2 = et;
          et2.tm_usec += 600000000L;
          PR_NormalizeTime(&et2, PR_USPacificTimeParameters);

          if (!ExplodedTimeIsEqual(&et1, &et2)) {
            printf("ERROR: componentwise comparison failed\n");
            PrintExplodedTime(&et1);
            printf("\n");
            PrintExplodedTime(&et2);
            printf("\n");
            failed_already = 1;
            return 1;
          }

          if (LL_NE(usecs, PR_ImplodeTime(&et1))) {
            printf(
                "ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n");
            PrintExplodedTime(&et1);
            printf("\n");
            failed_already = 1;
            return 1;
          }
          testParseTimeString(usecs);

          if (!dstInEffect && et1.tm_params.tp_dst_offset) {
            dstInEffect = 1;
            if (debug_mode) {
              printf("DST changeover from ");
              PrintExplodedTime(&et);
              printf(" to ");
              PrintExplodedTime(&et1);
              printf(".\n");
            }
          } else if (dstInEffect && !et1.tm_params.tp_dst_offset) {
            dstInEffect = 0;
            if (debug_mode) {
              printf("DST changeover from ");
              PrintExplodedTime(&et);
              printf(" to ");
              PrintExplodedTime(&et1);
              printf(".\n");
            }
          }

          et = et1;
        }
      }
    }
    if (debug_mode) {
      printf("Test passed\n");
    }
  }

  /* Same stress test, but with PR_LocalTimeParameters */

  {
    PRExplodedTime et, et1, et2;
    PRInt64 usecPer10Min;
    int day, hour, min;
    PRTime usecs;
    int dstInEffect = 0;

    if (debug_mode) {
      printf("\n");
      printf("*******************************************************\n");
      printf("**                                                   **\n");
      printf("**         Stress test    Local Time                 **\n");
      printf("**  Starting from midnight Jan. 1, 2005 PST,         **\n");
      printf("**  going through four years in 10-minute increment  **\n");
      printf("**                                                   **\n");
      printf("*******************************************************\n\n");
    }

    LL_I2L(usecPer10Min, 600000000L);

    /* 00:00:00 PST Jan. 1, 2005 */
    et.tm_usec = 0;
    et.tm_sec = 0;
    et.tm_min = 0;
    et.tm_hour = 0;
    et.tm_mday = 1;
    et.tm_month = 0;
    et.tm_year = 2005;
    et.tm_params.tp_gmt_offset = -8 * 3600;
    et.tm_params.tp_dst_offset = 0;
    usecs = PR_ImplodeTime(&et);

    for (day = 0; day < 4 * 365 + 1; day++) {
      for (hour = 0; hour < 24; hour++) {
        for (min = 0; min < 60; min += 10) {
          LL_ADD(usecs, usecs, usecPer10Min);
          PR_ExplodeTime(usecs, PR_LocalTimeParameters, &et1);

          et2 = et;
          et2.tm_usec += 600000000L;
          PR_NormalizeTime(&et2, PR_LocalTimeParameters);

          if (!ExplodedTimeIsEqual(&et1, &et2)) {
            printf("ERROR: componentwise comparison failed\n");
            PrintExplodedTime(&et1);
            printf("\n");
            PrintExplodedTime(&et2);
            printf("\n");
            return 1;
          }

          if (LL_NE(usecs, PR_ImplodeTime(&et1))) {
            printf(
                "ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n");
            PrintExplodedTime(&et1);
            printf("\n");
            failed_already = 1;
            return 1;
          }
          testParseTimeString(usecs);

          if (!dstInEffect && et1.tm_params.tp_dst_offset) {
            dstInEffect = 1;
            if (debug_mode) {
              printf("DST changeover from ");
              PrintExplodedTime(&et);
              printf(" to ");
              PrintExplodedTime(&et1);
              printf(".\n");
            }
          } else if (dstInEffect && !et1.tm_params.tp_dst_offset) {
            dstInEffect = 0;
            if (debug_mode) {
              printf("DST changeover from ");
              PrintExplodedTime(&et);
              printf(" to ");
              PrintExplodedTime(&et1);
              printf(".\n");
            }
          }

          et = et1;
        }
      }
    }
    if (debug_mode) {
      printf("Test passed\n");
    }
  }

  /* Same stress test, but with PR_LocalTimeParameters and going backward */

  {
    PRExplodedTime et, et1, et2;
    PRInt64 usecPer10Min;
    int day, hour, min;
    PRTime usecs;
    int dstInEffect = 0;

    if (debug_mode) {
      printf("\n");
      printf("*******************************************************\n");
      printf("**                                                   **\n");
      printf("**           Stress test    Local Time               **\n");
      printf("**  Starting from midnight Jan. 1, 2009 PST,         **\n");
      printf("**  going back four years in 10-minute increment     **\n");
      printf("**                                                   **\n");
      printf("*******************************************************\n\n");
    }

    LL_I2L(usecPer10Min, 600000000L);

    /* 00:00:00 PST Jan. 1, 2009 */
    et.tm_usec = 0;
    et.tm_sec = 0;
    et.tm_min = 0;
    et.tm_hour = 0;
    et.tm_mday = 1;
    et.tm_month = 0;
    et.tm_year = 2009;
    et.tm_params.tp_gmt_offset = -8 * 3600;
    et.tm_params.tp_dst_offset = 0;
    usecs = PR_ImplodeTime(&et);

    for (day = 0; day < 4 * 365 + 1; day++) {
      for (hour = 0; hour < 24; hour++) {
        for (min = 0; min < 60; min += 10) {
          LL_SUB(usecs, usecs, usecPer10Min);
          PR_ExplodeTime(usecs, PR_LocalTimeParameters, &et1);

          et2 = et;
          et2.tm_usec -= 600000000L;
          PR_NormalizeTime(&et2, PR_LocalTimeParameters);

          if (!ExplodedTimeIsEqual(&et1, &et2)) {
            printf("ERROR: componentwise comparison failed\n");
            PrintExplodedTime(&et1);
            printf("\n");
            PrintExplodedTime(&et2);
            printf("\n");
            return 1;
          }

          if (LL_NE(usecs, PR_ImplodeTime(&et1))) {
            printf(
                "ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n");
            PrintExplodedTime(&et1);
            printf("\n");
            failed_already = 1;
            return 1;
          }
          testParseTimeString(usecs);

          if (!dstInEffect && et1.tm_params.tp_dst_offset) {
            dstInEffect = 1;
            if (debug_mode) {
              printf("DST changeover from ");
              PrintExplodedTime(&et);
              printf(" to ");
              PrintExplodedTime(&et1);
              printf(".\n");
            }
          } else if (dstInEffect && !et1.tm_params.tp_dst_offset) {
            dstInEffect = 0;
            if (debug_mode) {
              printf("DST changeover from ");
              PrintExplodedTime(&et);
              printf(" to ");
              PrintExplodedTime(&et1);
              printf(".\n");
            }
          }

          et = et1;
        }
      }
    }
  }

  if (failed_already) {
    return 1;
  } else {
    return 0;
  }
}
