/****************************************************************************
 * This file is part of the project AqHome.
 * AqHome (c) by 2023 Martin Preuss, all rights reserved.
 *
 * The license for this file can be found in the file COPYING which you
 * should have received along with this file.
 ****************************************************************************/

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif


#include "./init.h"
#include "./init_http.h"
#include "./init_mqtt.h"
#include "./aqhomestorage_p.h"
#include "./aqhomehttp.h"

#include "aqhome/msg/endpoint_tty.h"
#include "aqhome/ipc/endpoint_ipc.h"
#include "aqhome/mqtt/endpoint_mqttc.h"
#include "aqhome/http/endpoint_http.h"
#include "aqhome/http/httpservice_conf.h"
#include "aqhome/http/httpservice_http.h"
#include "aqhome/http/httpservice.h"

#include <gwenhywfar/gwenhywfar.h>
#include <gwenhywfar/args.h>
#include <gwenhywfar/debug.h>
#include <gwenhywfar/endpoint_tcpd.h>
#include <gwenhywfar/endpoint_msgio.h>
#include <gwenhywfar/directory.h>

#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif

#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <time.h>



/* ------------------------------------------------------------------------------------------------
 * defines
 * ------------------------------------------------------------------------------------------------
 */

//#define I18N(msg) msg
#define I18S(msg) msg



/* ------------------------------------------------------------------------------------------------
 * forward declarations
 * ------------------------------------------------------------------------------------------------
 */

static int _setupFolders(AQHOME_STORAGE *aqh, GWEN_DB_NODE *dbArgs);

static int _setupStorage(AQHOME_STORAGE *aqh, GWEN_DB_NODE *dbArgs);

static void _setupIpc(AQHOME_STORAGE *aqh, GWEN_DB_NODE *dbArgs);

static GWEN_MSG_ENDPOINT *_acceptIpcFn(GWEN_MSG_ENDPOINT *ep, GWEN_SOCKET *sk, const GWEN_INETADDRESS *addr, void *data);

static int _readArgs(int argc, char **argv, GWEN_DB_NODE *dbArgs);
static int _createPidFile(const char *pidFilename);



/* ------------------------------------------------------------------------------------------------
 * implementations
 * ------------------------------------------------------------------------------------------------
 */

int AqHomeStorage_Init(AQHOME_STORAGE *aqh, int argc, char **argv)
{
  GWEN_DB_NODE *dbArgs;
  int rv;
  const char *s;

  dbArgs=GWEN_DB_Group_new("args");
  rv=_readArgs(argc, argv, dbArgs);
  if (rv<0) {
    DBG_ERROR(NULL, "Error reading args (%d)", rv);
    return rv;
  }
  aqh->dbArgs=dbArgs;

  aqh->maxSessionAgeInSeconds=GWEN_DB_GetIntValue(dbArgs, "maxSessionAge", 0, AQHOME_STORAGE_DEFAULT_MAXSESSIONAGE);
  aqh->timeout=GWEN_DB_GetIntValue(dbArgs, "timeout", 0, 0);

  s=GWEN_DB_GetCharValue(dbArgs, "pidfile", 0, AQHOME_STORAGE_DEFAULT_PIDFILE);
  if (s && *s) {
    AqHomeStorage_SetPidFile(aqh, s);
    rv=_createPidFile(s);
    if (rv<0) {
      DBG_ERROR(NULL, "Error creating PID file (%d)", rv);
      return rv;
    }
  }

  rv=_setupFolders(aqh, dbArgs);
  if (rv<0) {
    DBG_INFO(NULL, "here (%d)", rv);
    return rv;
  }

  rv=_setupStorage(aqh, dbArgs);
  if (rv<0) {
    DBG_INFO(NULL, "here (%d)", rv);
    return rv;
  }

  _setupIpc(aqh, dbArgs);

  rv=AqHomeStorage_SetupMqtt(aqh, dbArgs);
  if (rv<0) {
    DBG_INFO(NULL, "here (%d)", rv);
    return rv;
  }

  rv=AqHomeStorage_SetupHttp(aqh, dbArgs);
  if (rv<0) {
    DBG_INFO(NULL, "here (%d)", rv);
    return rv;
  }

  return 0;
}



int _setupFolders(AQHOME_STORAGE *aqh, GWEN_DB_NODE *dbArgs)
{
  const char *s;
  GWEN_BUFFER *nameBuf;
  int pos;
  int rv;

  s=GWEN_DB_GetCharValue(dbArgs, "cfgdir", 0, AQHOME_STORAGE_DEFAULT_CONFIGDIR);
  if (!(s && *s)) {
    DBG_ERROR(NULL, "Missing configuration folder");
    return GWEN_ERROR_GENERIC;
  }

  nameBuf=GWEN_Buffer_new(0, 256, 0, 1);
  GWEN_Buffer_AppendString(nameBuf, s);
  pos=GWEN_Buffer_GetPos(nameBuf);
  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nameBuf), GWEN_PATH_FLAGS_CHECKROOT);
  if (rv<0) {
    DBG_ERROR(NULL, "Error accessing configuration folder \"%s\"", GWEN_Buffer_GetStart(nameBuf));
    GWEN_Buffer_free(nameBuf);
    return GWEN_ERROR_GENERIC;
  }
  GWEN_Buffer_Crop(nameBuf, 0, pos);

  GWEN_Buffer_AppendString(nameBuf, GWEN_DIR_SEPARATOR_S "modules");
  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nameBuf), GWEN_PATH_FLAGS_CHECKROOT);
  if (rv<0) {
    DBG_ERROR(NULL, "Error accessing modules folder \"%s\"", GWEN_Buffer_GetStart(nameBuf));
    GWEN_Buffer_free(nameBuf);
    return GWEN_ERROR_GENERIC;
  }
  GWEN_Buffer_Crop(nameBuf, 0, pos);

  GWEN_Buffer_AppendString(nameBuf, GWEN_DIR_SEPARATOR_S "users");
  rv=GWEN_Directory_GetPath(GWEN_Buffer_GetStart(nameBuf), GWEN_PATH_FLAGS_CHECKROOT);
  if (rv<0) {
    DBG_ERROR(NULL, "Error accessing configuration folder \"%s\"", GWEN_Buffer_GetStart(nameBuf));
    GWEN_Buffer_free(nameBuf);
    return GWEN_ERROR_GENERIC;
  }

  GWEN_Buffer_free(nameBuf);
  return 0;
}




int _setupStorage(AQHOME_STORAGE *aqh, GWEN_DB_NODE *dbArgs)
{
  const char *dataFolder;
  const char *stateFile;

  dataFolder=GWEN_DB_GetCharValue(dbArgs, "dataFolder", 0, AQHOME_STORAGE_DEFAULT_DATADIR);
  stateFile=GWEN_DB_GetCharValue(dbArgs, "stateFile", 0, NULL);
  if (stateFile && *stateFile) {
    AQH_STORAGE *sto;
    int rv;

    sto=AQH_Storage_new();
    AQH_Storage_SetStateFile(sto, stateFile);

    AQH_Storage_SetDataFileFolder(sto, (dataFolder && *dataFolder)?dataFolder:NULL);

    rv=AQH_Storage_Init(sto);
    if (rv<0) {
      DBG_INFO(NULL, "here (%d)", rv);
      AQH_Storage_free(sto);
      return rv;
    }
    aqh->storage=sto;
  }
  else {
    DBG_ERROR(NULL, "No state file given");
    return GWEN_ERROR_GENERIC;
  }
  return 0;
}



void _setupIpc(AQHOME_STORAGE *aqh, GWEN_DB_NODE *dbArgs)
{
  const char *tcpAddress;
  int tcpPort;

  tcpAddress=GWEN_DB_GetCharValue(dbArgs, "tcpAddress", 0, NULL);
  tcpPort=GWEN_DB_GetIntValue(dbArgs, "tcpPort", 0, AQHOME_STORAGE_DEFAULT_IPC_PORT);

  if (tcpAddress && *tcpAddress && tcpPort) {
    GWEN_MSG_ENDPOINT *ep;

    ep=GWEN_TcpdEndpoint_new(tcpAddress, tcpPort, NULL, 0);
    GWEN_TcpdEndpoint_SetAcceptFn(ep, _acceptIpcFn, aqh);

    GWEN_MsgEndpoint_Tree2_AddChild(aqh->rootEndpoint, ep);
    aqh->ipcdEndpoint=ep;
  }
}



GWEN_MSG_ENDPOINT *_acceptIpcFn(GWEN_MSG_ENDPOINT *ep,
                                GWEN_SOCKET *sk,
                                const GWEN_INETADDRESS *addr,
                                GWEN_UNUSED void *data)
{
/*  AQHOME_STORAGE *aqh;
 *
 *  aqh=(AQHOME_STORAGE*) data;
 */
  DBG_INFO(NULL, "Incoming IPC connection");
  return AQH_IpcEndpoint_CreateIpcTcpServiceForSocket(sk, NULL, 0);
}



int _createPidFile(const char *pidFilename)
{
  FILE *f;
  int pidfd;

  if (remove(pidFilename)==0) {
    DBG_ERROR(0, "Old PID file existed, removed. (Unclean shutdown?)");
  }

#ifdef HAVE_SYS_STAT_H
  pidfd = open(pidFilename, O_EXCL|O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
  if (pidfd < 0) {
    DBG_ERROR(NULL, "Could not create PID file \"%s\" (%s), aborting.", pidFilename, strerror(errno));
    return GWEN_ERROR_IO;
  }

  f = fdopen(pidfd, "w");
#else /* HAVE_STAT_H */
  f=fopen(pidFilename,"w+");
#endif /* HAVE_STAT_H */

  /* write pid */
#ifdef HAVE_GETPID
  fprintf(f,"%d\n",getpid());
#else
  fprintf(f,"-1\n");
#endif
  if (fclose(f)) {
    DBG_ERROR(0, "Could not close PID file \"%s\" (%s), aborting.", pidFilename, strerror(errno));
    return GWEN_ERROR_IO;
  }
  return 0;
}




int _readArgs(int argc, char **argv, GWEN_DB_NODE *dbArgs)
{
  int rv;
  const GWEN_ARGS args[]= {
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "cfgdir",                     /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      "D",                          /* short option */
      "cfgdir",                     /* long option */
      I18S("Specify the configuration folder"),
      I18S("Specify the configuration folder")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "tcpAddress",                 /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      "t",                          /* short option */
      "tcpaddress",                 /* long option */
      I18S("Specify the TCP address to listen on (disabled if missing)"),
      I18S("Specify the TCP address to listen on (disabled if missing)")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Int,            /* type */
      "tcpPort",                    /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      "P",                          /* short option */
      "tcpport",                    /* long option */
      I18S("Specify the TCP port to listen on"),
      I18S("Specify the TCP port to listen on")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "mqttAddress",                 /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      "ma",                         /* short option */
      "mqttaddress",                 /* long option */
      I18S("Specify the address of the MQTT server to connect to (disabled if missing)"),
      I18S("Specify the address of the MQTT server to connect to (disabled if missing)")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Int,            /* type */
      "mqttPort",                    /* name */
      0,                             /* minnum */
      1,                             /* maxnum */
      "mp",                          /* short option */
      "mqttport",                    /* long option */
      I18S("Specify the port of the MQTT server (default: 1883)"),
      I18S("Specify the port of the MQTT server (default: 1883)")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "mqttClientId",                /* name */
      0,                             /* minnum */
      1,                             /* maxnum */
      NULL,                          /* short option */
      "mqttclientid",                /* long option */
      I18S("Specify client id for the MQTT server (default: \"AQHOMESTORAGE\")"),
      I18S("Specify client id for the MQTT server (default: \"AQHOMESTORAGE\")")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Int,            /* type */
      "mqttKeepAlive",              /* name */
      0,                             /* minnum */
      1,                             /* maxnum */
      "mk",                          /* short option */
      "mqttkeepalive",                    /* long option */
      I18S("Specify keepalive time in seconds (defaults: 600)"),
      I18S("Specify keepalive time in seconds (defaults: 600)")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "httpAddress",                 /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      "ha",                         /* short option */
      "httpaddress",                 /* long option */
      I18S("Specify the address to bind the http service to (disabled if missing)"),
      I18S("Specify the address to bind the http service to (disabled if missing)")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Int,            /* type */
      "httpPort",                    /* name */
      0,                             /* minnum */
      1,                             /* maxnum */
      "hp",                          /* short option */
      "httpport",                    /* long option */
      I18S("Specify the port to listen on for HTTP connections"),
      I18S("Specify the port to listen on for HTTP connections")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Int,            /* type */
      "maxSessionAge",              /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      NULL,                          /* short option */
      "maxsessionage",               /* long option */
      I18S("Specify maximum session age in seconds (default: 30mins)"),
      I18S("Specify maximum session age in seconds (default: 30mins)")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "sourcefolder",               /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      NULL,                         /* short option */
      "sourcefolder",               /* long option */
      I18S("Folder where static HTML source files are stored"),
      I18S("Folder where static HTML source files are stored")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "datafolder",                 /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      NULL,                         /* short option */
      "datafolder",                 /* long option */
      I18S("Folder where data files are stored"),
      I18S("Folder where data files are stored")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "statefile",                  /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      "S",                          /* short option */
      "statefile",                  /* long option */
      I18S("File where rooms, devices and values etc. are stored"),
      I18S("File where rooms, devices and values etc. are stored")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Char,           /* type */
      "pidfile",                    /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      "p",                          /* short option */
      "pidfile",                    /* long option */
      I18S("Specify the PID file"),
      I18S("Specify the PID file")
    },
    {
      GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
      GWEN_ArgsType_Int,            /* type */
      "timeout",                    /* name */
      0,                            /* minnum */
      1,                            /* maxnum */
      "T",                          /* short option */
      "timeout",                     /* long option */
      I18S("Specify timeout in second (default: no timeout)"),
      I18S("Specify timeout in second (default: no timeout)")
    },
    {
      GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */
      GWEN_ArgsType_Int,            /* type */
      "help",                       /* name */
      0,                            /* minnum */
      0,                            /* maxnum */
      "h",                          /* short option */
      "help",
      I18S("Show this help screen."),
      I18S("Show this help screen.")
    }
  };

  rv=GWEN_Args_Check(argc, argv, 1, 0, args, dbArgs);
  if (rv==GWEN_ARGS_RESULT_ERROR) {
    fprintf(stderr, "ERROR: Could not parse arguments main\n");
    return GWEN_ERROR_INVALID;
  }
  else if (rv==GWEN_ARGS_RESULT_HELP) {
    GWEN_BUFFER *ubuf;

    ubuf=GWEN_Buffer_new(0, 1024, 0, 1);
    GWEN_Buffer_AppendArgs(ubuf,
                           I18N("This is version %s.\nUsage: %s [OPTIONS]\n\nOptions:\n"),
                           AQHOME_VERSION_STRING,
                           argv[0]);
    if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {
      fprintf(stderr, "ERROR: Could not create help string\n");
      return 1;
    }
    GWEN_Buffer_AppendString(ubuf, "\n");

    fprintf(stdout, "%s\n", GWEN_Buffer_GetStart(ubuf));
    GWEN_Buffer_free(ubuf);
    return GWEN_ERROR_CLOSE;
  }
  return 0;
}



