/*
 * Copyright (c) 2019, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer in the documentation and/or other materials provided
 *      with the distribution.
 *    * Neither the name of The Linux Foundation nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

//#include "qurt_mutex.h"
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <assert.h>
#include <pthread.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <sys/eventfd.h>

#include "platform_libs.h"
#include "HAP_farf.h"
#include "verify.h"
#include "mod_table.h"
#include "remote_priv.h"
#include "rpcmem.h"
#include "adsp_listener.h"
#include "listener_buf.h"
#include "shared.h"
#include "AEEstd.h"
#include "fastrpc_apps_user.h"
#include "AEEStdErr.h"

#define LOGL(format, ...) VERIFY_PRINT_INFO(format, ##__VA_ARGS__)
#ifndef MALLOC
#define MALLOC malloc
#endif

#ifndef CALLOC
#define CALLOC calloc
#endif

#ifndef FREE
#define FREE free
#endif

#ifndef REALLOC
#define REALLOC realloc
#endif

#ifndef FREEIF
#define FREEIF(pv) \
   do {\
      if(pv) { \
         void* tmp = (void*)pv;\
         pv = 0;\
         FREE(tmp);\
      } \
   } while(0)
#endif

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/eventfd.h>

struct listener {
   pthread_t thread;
   int eventfd;
};

static struct listener linfo[NUM_DOMAINS_EXTEND] =
{ [0 ... NUM_DOMAINS_EXTEND - 1] = { .thread = 0, .eventfd = -1 } };

//TODO: fix this to work over any number of buffers
//      needs qaic to support extra buffers
#define MAX_BUFS 250
struct invoke_bufs {
   adsp_listener_buffer outbufs[MAX_BUFS];
   adsp_listener_buffer inbufs[MAX_BUFS];
   int inbufLenReqs[MAX_BUFS];
   int outbufLenReqs[MAX_BUFS];
   remote_arg args[2*MAX_BUFS];
};

extern void set_thread_context(int domain);

__QAIC_IMPL_EXPORT int __QAIC_IMPL(apps_remotectl_open)(const char* name, uint32* handle, char* dlStr, int dlerrorLen, int* dlErr) __QAIC_IMPL_ATTRIBUTE
{
   return mod_table_open(name, handle, dlStr, dlerrorLen, dlErr);
}

__QAIC_IMPL_EXPORT int __QAIC_IMPL(apps_remotectl_close)(uint32 handle, char* errStr, int errStrLen, int* dlErr) __QAIC_IMPL_ATTRIBUTE
{
   return mod_table_close(handle, errStr, errStrLen, dlErr);
}

#define RPC_FREEIF(heapid, buf) \
do {\
   if(heapid == -1)  {\
      FREEIF(buf);\
   } else {\
      if(buf) {\
         rpcmem_free_internal(buf);\
         buf = 0;\
      }\
   }\
} while (0)

static __inline void* rpcmem_realloc(int heapid, uint32 flags, void* buf, int oldsize, int size) {
   if(heapid == -1) {
      return REALLOC(buf, size);
   } else {
      void* bufnew = rpcmem_alloc_internal(heapid, flags, size);
      if(buf && bufnew) {
         memmove(bufnew, buf, oldsize);
         rpcmem_free_internal(buf);
         buf = NULL;
      }
      return bufnew;
   }
}

static void* listener(void* arg) {
   struct listener* me = (struct listener*)arg;
   int numOutBufs = 0;
   int nErr = AEE_SUCCESS;
   adsp_listener_invoke_ctx ctx = 0;
   struct invoke_bufs* bufs = 0;
   boolean bNeedMore;
   int result = -1;
   adsp_listener_remote_handle handle;
   uint32 sc;
   int ii, inBufsAllocated = 0;
   const char* eheap = getenv("ADSP_LISTENER_HEAP_ID");
   int heapid = eheap == 0 ? 0 : (uint32)atoi(eheap);
   const char* eflags = getenv("ADSP_LISTENER_HEAP_FLAGS");
   uint32 flags = eflags == 0 ? RPCMEM_HEAP_DEFAULT : (uint32)atoi(eflags);

   if(eheap || eflags) {
      FARF(HIGH, "listener using ion heap: %d flags: %x\n", (int)heapid, (int)flags);
   }

   VERIFYC(NULL != (bufs = rpcmem_realloc(heapid, flags, 0, 0, sizeof(*bufs))), AEE_ENORPCMEMORY);
   memset(bufs, 0, sizeof(*bufs));
   set_thread_context((int)(me - &linfo[0]));

   do {
 invoke:
      bNeedMore = FALSE;
      sc = 0xffffffff;
      if(result != AEE_SUCCESS) {
         numOutBufs = 0;
      }
      nErr = __QAIC_HEADER(adsp_listener_next_invoke)(
                        ctx, result, bufs->outbufs, numOutBufs, &ctx,
                        &handle, &sc, bufs->inbufs, inBufsAllocated,
                        bufs->inbufLenReqs, MAX_BUFS, bufs->outbufLenReqs, MAX_BUFS);
      if(nErr) {
         VERIFY_EPRINTF("listener protocol failure %x\n", nErr);
         VERIFY(AEE_SUCCESS == (nErr = __QAIC_HEADER(adsp_listener_next_invoke)(
                        ctx, nErr, 0, 0, &ctx,
                        &handle, &sc, bufs->inbufs, inBufsAllocated,
                        bufs->inbufLenReqs, MAX_BUFS, bufs->outbufLenReqs, MAX_BUFS)));
      }

      if(MAX_BUFS < REMOTE_SCALARS_INBUFS(sc) || MAX_BUFS < REMOTE_SCALARS_OUTBUFS(sc)) {
         result = AEE_EMAXBUFS;
         goto invoke;
      }
      for(ii = 0; ii < (int)REMOTE_SCALARS_INBUFS(sc); ++ii) {
         if(bufs->inbufs[ii].dataLen < bufs->inbufLenReqs[ii]) {
            if(0 != bufs->inbufLenReqs[ii]) {
               bufs->inbufs[ii].data = rpcmem_realloc(heapid, flags, bufs->inbufs[ii].data,  bufs->inbufs[ii].dataLen, bufs->inbufLenReqs[ii]);
               if(0 == bufs->inbufs[ii].data) {
                  bufs->inbufs[ii].dataLen = 0;
                  result = AEE_ENORPCMEMORY;
                  goto invoke;
               }
            }
            bufs->inbufs[ii].dataLen = bufs->inbufLenReqs[ii];
            inBufsAllocated = STD_MAX(inBufsAllocated, ii + 1);
            bNeedMore = TRUE;
         }
         bufs->args[ii].buf.pv = bufs->inbufs[ii].data;
         bufs->args[ii].buf.nLen = bufs->inbufLenReqs[ii];
      }
      for(ii = 0; ii < (int)REMOTE_SCALARS_OUTBUFS(sc); ++ii) {
         if(bufs->outbufs[ii].dataLen < bufs->outbufLenReqs[ii]) {
            if(0 !=  bufs->outbufLenReqs[ii]) {
               bufs->outbufs[ii].data = rpcmem_realloc(heapid, flags, bufs->outbufs[ii].data, bufs->outbufs[ii].dataLen, bufs->outbufLenReqs[ii]);
               if(0 == bufs->outbufs[ii].data) {
                  result = AEE_ENORPCMEMORY;
                  goto invoke;
               }
            }
            bufs->outbufs[ii].dataLen = bufs->outbufLenReqs[ii];
         }
         bufs->args[ii + REMOTE_SCALARS_INBUFS(sc)].buf.pv = bufs->outbufs[ii].data;
         bufs->args[ii + REMOTE_SCALARS_INBUFS(sc)].buf.nLen = bufs->outbufLenReqs[ii];
      }
      numOutBufs = REMOTE_SCALARS_OUTBUFS(sc);
      if(bNeedMore) {
         assert(inBufsAllocated >= REMOTE_SCALARS_INBUFS(sc));
         if(0 != (result = __QAIC_HEADER(adsp_listener_invoke_get_in_bufs)(ctx, bufs->inbufs,
                                                                  REMOTE_SCALARS_INBUFS(sc)))) {
            FARF(HIGH, "adsp_listener_invoke_get_in_bufs failed  %x\n", result);
            goto invoke;
         }
      }

      result = mod_table_invoke(handle, sc, bufs->args);
   } while(1);
bail:
   for(ii = 0; ii < MAX_BUFS && bufs; ++ii) {
      RPC_FREEIF(heapid, bufs->outbufs[ii].data);
      RPC_FREEIF(heapid, bufs->inbufs[ii].data);
   }
   RPC_FREEIF(heapid, bufs);
   if(nErr != AEE_SUCCESS) {
      VERIFY_EPRINTF("Error %x: listener thread exiting\n", nErr);
   }
   return (void*)(uintptr_t)nErr;
}

static int listener_start_thread(struct listener* me) {
   return pthread_create(&me->thread, 0, listener, (void*)me);
}
#define MIN_BUF_SIZE 0x1000
#define ALIGNB(sz) ((sz) == 0 ? MIN_BUF_SIZE : _SBUF_ALIGN((sz), MIN_BUF_SIZE))

static void* listener2(void* arg) {
   struct listener* me = (struct listener*)arg;
   int nErr = AEE_SUCCESS;
   adsp_listener_invoke_ctx ctx = 0;
   uint8* outBufs = 0;
   int outBufsLen = 0, outBufsCapacity = 0;
   uint8* inBufs = 0;
   int inBufsLen = 0, inBufsLenReq = 0;
   int result = -1;
   adsp_listener_remote_handle handle = -1;
   uint32 sc = 0;
   const char* eheap = getenv("ADSP_LISTENER_HEAP_ID");
   int heapid = eheap == 0 ? -1 : atoi(eheap);
   const char* eflags = getenv("ADSP_LISTENER_HEAP_FLAGS");
   uint32 flags = eflags == 0 ? 0 : (uint32)atoi(eflags);
   const char* emin = getenv("ADSP_LISTENER_MEM_CACHE_SIZE");
   int cache_size = emin == 0 ? 0 : atoi(emin);
   remote_arg args[512];
   struct sbuf buf;
   eventfd_t event = 0xff;

   memset(args, 0, sizeof(args));
   set_thread_context((int)(me - &linfo[0]));
   if(eheap || eflags || emin) {
      FARF(HIGH, "listener using ion heap: %d flags: %x cache: %lld\n", (int)heapid, (int)flags, cache_size);
   }

   do {
 invoke:
      sc = 0xffffffff;
      if(result != 0) {
         outBufsLen = 0;
      }
      FARF(HIGH, "responding message for %x %x %x %x", ctx, handle, sc, result);
      nErr = __QAIC_HEADER(adsp_listener_next2)(
                        ctx, result, outBufs, outBufsLen,
                        &ctx, &handle, &sc, inBufs, inBufsLen, &inBufsLenReq);
      FARF(HIGH, "got message for %x %x %x %x", ctx, handle, sc, nErr);
      if(nErr) {
         VERIFY_EPRINTF("listener protocol failure %x\n", nErr);
         if (nErr == AEE_EINTERRUPTED) {
            goto invoke;
         }
         VERIFY(0 == (nErr = __QAIC_HEADER(adsp_listener_next2)(
                        ctx, nErr, 0, 0,
                        &ctx, &handle, &sc, inBufs, inBufsLen,
                        &inBufsLenReq)));
      }
      if(ALIGNB(inBufsLenReq * 2) < inBufsLen && inBufsLen > cache_size) {
         void* buf;
         int size = ALIGNB(inBufsLenReq * 2);
         if(NULL == (buf = rpcmem_realloc(heapid, flags, inBufs, inBufsLen, size))) {
            result = AEE_ENORPCMEMORY;
            FARF(HIGH, "rpcmem_realloc shrink failed");
            goto invoke;
         }
         inBufs = buf;
         inBufsLen = size;
      }
      if(inBufsLenReq > inBufsLen) {
         void* buf;
         int req;
         int oldLen = inBufsLen;
         int size = _SBUF_ALIGN(inBufsLenReq, MIN_BUF_SIZE);
         if(AEE_SUCCESS == (buf = rpcmem_realloc(heapid, flags, inBufs, inBufsLen, size))) {
            result = AEE_ENORPCMEMORY;
            FARF(ERROR, "rpcmem_realloc failed");
            goto invoke;
         }
         inBufs = buf;
         inBufsLen = size;
         if(0 != (result = __QAIC_HEADER(adsp_listener_get_in_bufs2)(ctx, oldLen,
                                                                     inBufs + oldLen,
                                                                     inBufsLen - oldLen, &req))) {
            FARF(HIGH, "adsp_listener_invoke_get_in_bufs2 failed  %x", result);
            goto invoke;
         }
         if(req > inBufsLen) {
            result = AEE_EBADSIZE;
            FARF(HIGH, "adsp_listener_invoke_get_in_bufs2 failed  %x", result);
            goto invoke;
         }
      }
      if(REMOTE_SCALARS_INHANDLES(sc) + REMOTE_SCALARS_OUTHANDLES(sc) > 0) {
         result = AEE_EINVARGS;
         goto invoke;
      }

      sbuf_init(&buf, 0, inBufs, inBufsLen);
      unpack_in_bufs(&buf, args,  REMOTE_SCALARS_INBUFS(sc));
      unpack_out_lens(&buf, args + REMOTE_SCALARS_INBUFS(sc), REMOTE_SCALARS_OUTBUFS(sc));

      sbuf_init(&buf, 0, 0, 0);
      pack_out_bufs(&buf, args + REMOTE_SCALARS_INBUFS(sc), REMOTE_SCALARS_OUTBUFS(sc));
      outBufsLen = sbuf_needed(&buf);

      if(ALIGNB(outBufsLen*2) < outBufsCapacity && outBufsCapacity > cache_size) {
         void* buf;
         int size = ALIGNB(outBufsLen*2);
         if(NULL == (buf = rpcmem_realloc(heapid, flags, outBufs, outBufsCapacity, size))) {
            result = AEE_ENORPCMEMORY;
            FARF(HIGH, "listener rpcmem_realloc shrink failed");
            goto invoke;
         }
         outBufs = buf;
         outBufsCapacity = size;
      }
      if(outBufsLen > outBufsCapacity) {
         void* buf;
         int size = ALIGNB(outBufsLen);
         if(NULL == (buf = rpcmem_realloc(heapid, flags, outBufs, outBufsCapacity, size))) {
            result = AEE_ENORPCMEMORY;
            FARF(ERROR, "listener rpcmem_realloc failed");
            goto invoke;
         }
         outBufs = buf;
         outBufsLen = size;
         outBufsCapacity = size;
      }
      sbuf_init(&buf, 0, outBufs, outBufsLen);
      pack_out_bufs(&buf, args + REMOTE_SCALARS_INBUFS(sc), REMOTE_SCALARS_OUTBUFS(sc));

      result = mod_table_invoke(handle, sc, args);
   } while(1);
bail:
   RPC_FREEIF(heapid, outBufs);
   RPC_FREEIF(heapid, inBufs);
   if(nErr != AEE_SUCCESS) {
      VERIFY_EPRINTF("Error %x: listener thread exited", nErr);
   }
   eventfd_write(me->eventfd, event);
   dlerror();
   return (void*)(uintptr_t)nErr;
}
static int listener_start_thread2(struct listener* me) {
   return pthread_create(&me->thread, 0, listener2, (void*)me);
}

extern int apps_remotectl_skel_invoke(uint32 _sc, remote_arg* _pra);
extern int apps_std_skel_invoke(uint32 _sc, remote_arg* _pra);
extern int apps_mem_skel_invoke(uint32 _sc, remote_arg* _pra);
extern int adspmsgd_apps_skel_invoke(uint32_t _sc, remote_arg* _pra);

#include "adsp_listener_stub.c"
PL_DEP(mod_table)
PL_DEP(apps_std);

void listener_android_deinit(void) {
   PL_DEINIT(mod_table);
   PL_DEINIT(apps_std);
}

int listener_android_init(void) {
   int nErr = 0;

   VERIFY(AEE_SUCCESS == (nErr = PL_INIT(mod_table)));
   VERIFY(AEE_SUCCESS == (nErr = PL_INIT(apps_std)));
   VERIFY(AEE_SUCCESS == (nErr = mod_table_register_const_handle(0, "apps_remotectl", apps_remotectl_skel_invoke)));
   VERIFY(AEE_SUCCESS == (nErr = mod_table_register_static("apps_std", apps_std_skel_invoke)));
   VERIFY(AEE_SUCCESS == (nErr = mod_table_register_static("apps_mem", apps_mem_skel_invoke)));
   VERIFY(AEE_SUCCESS == (nErr = mod_table_register_static("adspmsgd_apps", adspmsgd_apps_skel_invoke)));
bail:
   if(nErr != AEE_SUCCESS) {
      listener_android_deinit();
      VERIFY_EPRINTF("Error %x: fastrpc listener initialization error", nErr);
   }
   return nErr;
}

void listener_android_domain_deinit(int domain) {
   struct listener* me = &linfo[domain];

   FARF(HIGH, "fastrpc listener joining to exit");
   if(me->thread) {
      pthread_join(me->thread, 0);
      me->thread = 0;
   }
   FARF(HIGH, "fastrpc listener joined");
   if(me->eventfd != -1) {
      close(me->eventfd);
      me->eventfd = -1;
   }
}

int listener_android_domain_init(int domain) {
   struct listener* me = &linfo[domain];
   int nErr = 0;

   VERIFYC(-1 != (me->eventfd = eventfd(0, 0)), AEE_EINVALIDFD);
   nErr = __QAIC_HEADER(adsp_listener_init2)();
   if(AEE_EUNSUPPORTEDAPI == nErr) {
      FARF(HIGH, "listener2 initialization error falling back to listener1 %x", nErr);
      VERIFY(AEE_SUCCESS == (nErr = __QAIC_HEADER(adsp_listener_init)()));
      VERIFY(AEE_SUCCESS == (nErr = listener_start_thread(me)));
   } else if(AEE_SUCCESS == nErr) {
      FARF(HIGH, "listener2 initialized for domain %d", domain);
      VERIFY(AEE_SUCCESS == (nErr = listener_start_thread2(me)));
   }

bail:
   if(nErr != AEE_SUCCESS) {
      VERIFY_EPRINTF("Error %x: listener android domain init failed. domain %d\n", nErr, domain);
      listener_android_domain_deinit(domain);
   }
   return nErr;
}

int listener_android_geteventfd(int domain, int *fd) {
   struct listener* me = &linfo[domain];
   int nErr = 0;

   VERIFYC(-1 != me->eventfd, AEE_EINVALIDFD);
   *fd = me->eventfd;
bail:
   if (nErr != AEE_SUCCESS) {
	VERIFY_EPRINTF("Error %x: listener android getevent file descriptor failed for domain %d\n", nErr, domain);
   }
   return nErr;
}

PL_DEFINE(listener_android, listener_android_init, listener_android_deinit)