/*
    Garmin Jeeps - OpenCPN Interface Wrapper.

    Copyright (C) 2010 David S Register

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, see <https://www.gnu.org/licenses/>.
 */

/**
 * \file
 *
 * Implement garmin_wrapper.h -- OpenCPN Interface Wrapper for garmin
 * library.
 */

#include "config.h"

#include "model/garmin_wrapper.h"

#include "gpsapp.h"
#include "garmin_gps.h"
#include "gpsserial.h"

#define GPS_DEBUG

static gpsdevh *my_gps_devh;

wxString GetLastGarminError() {
  return wxString(GetDeviceLastError(), wxConvUTF8);
}

/*
      Verify and force port closure after every called routine.
      This is necessary for aborts in Windows environment, since ports cannot be
   multiply opened.
*/

/*  Wrapped interface from higher level objects   */
int Garmin_GPS_Init(const wxString &port_name) {
  int ret;
  GPS_Enable_Error();
  GPS_Enable_Warning();
  GPS_Enable_User();
  GPS_Enable_Diagnose();
  char m[1];
  m[0] = '\0';

  GPS_Error(m);

  ret = GPS_Init(port_name.mb_str());
  VerifyPortClosed();

  return ret;
}

int Garmin_GPS_Open(wxString &port_name) {
  return GPS_Init(port_name.mb_str());
}

int Garmin_GPS_PVT_On(wxString &port_name) {
  return Garmin_Serial_GPS_PVT_On(port_name.mb_str());
}

int Garmin_GPS_PVT_Off(wxString &port_name) {
  return Garmin_Serial_GPS_PVT_Off(port_name.mb_str());
}

int Garmin_GPS_GetPVT(void *pvt) {
  return GPS_Serial_Command_Pvt_Get((GPS_PPvt_Data *)pvt);
}

void Garmin_GPS_ClosePortVerify() { VerifyPortClosed(); }

wxString Garmin_GPS_GetSaveString() {
  return wxString(gps_save_string, wxConvUTF8);
}

void Garmin_GPS_PrepareWptData(GPS_PWay pway, RoutePoint *prp) {
  pway->lat = prp->m_lat;
  pway->lon = prp->m_lon;
  pway->alt_is_unknown = 1;
  pway->alt = 0.0;
  strncpy(pway->ident, (prp->GetName().Truncate(6)).mb_str(), 6);
}

int Garmin_GPS_SendWaypoints(const wxString &port_name,
                             RoutePointList *wplist) {
  int ret_val = 0;

  int nPoints = wplist->size();

  // Create the array of GPS_PWays

  GPS_SWay **ppway = (GPS_SWay **)malloc(nPoints * sizeof(GPS_PWay));

  //    and the GPS_Oways themselves
  for (int i = 0; i < nPoints; i++) ppway[i] = GPS_Way_New();

  //    Now fill in the useful elements
  for (int i = 0; i < nPoints; i++) {
    GPS_PWay pway = ppway[i];
    auto it = wplist->begin() + i;
    RoutePoint *prp = *it;

    Garmin_GPS_PrepareWptData(pway, prp);
  }

  //    Transmit the list to the GPS receiver
  int xfer_result = GPS_Command_Send_Waypoint(
      port_name.mb_str(), ppway, nPoints, 0 /*int (*cb)(GPS_PWay *)*/);
  ret_val = xfer_result;

  //  Free all the memory
  for (int i = 0; i < nPoints; i++) GPS_Way_Del(&ppway[i]);

  free(ppway);

  VerifyPortClosed();
  return ret_val;
}

// This routine creates an array of waypoint structures for an A200 route
// transfer according to the "Garmin GPS Interface Specification" page 20.
// The returned array contains the following packets:
//
//    route header packet
//    waypoint packet
//    ...
//    waypoint packet
//
// The total number of elements in the array (route header packet and
// all waypoint packets) is returned in the "size" argument.

GPS_SWay **Garmin_GPS_Create_A200_Route(Route *pr, int route_number,
                                        int *size) {
  RoutePointList *wplist = pr->pRoutePointList;
  int nPoints = wplist->size();

  // Create the array of GPS_PWays
  // There will be one extra for the route header

  *size = nPoints + 1;

  GPS_SWay **ppway = (GPS_SWay **)malloc((*size) * sizeof(GPS_PWay));

  //    and the GPS_Oways themselves
  for (int i = 0; i < nPoints + 1; i++) ppway[i] = GPS_Way_New();

  //    Now fill in the useful elements

  //    Element 0 is a route record

  GPS_PWay pway = ppway[0];
  pway->isrte = true;
  pway->rte_num = route_number;
  strncpy(pway->rte_ident, (pr->m_RouteNameString.Truncate(255)).mb_str(), 255);
  strncpy(pway->rte_cmnt, (pr->m_RouteNameString.Truncate(19)).mb_str(), 19);

  //    Elements 1..n are waypoints
  for (int i = 1; i < *size; i++) {
    GPS_PWay pway = ppway[i];
    auto it = wplist->begin() + i;
    RoutePoint *prp = *it;

    Garmin_GPS_PrepareWptData(pway, prp);
  }

  return ppway;
}

// This routine creates an array of waypoint structures for an A201 route
// transfer according to the "Garmin GPS Interface Specification" page 21.
// The returned array contains the following packets:
//
//    route header packet
//    waypoint packet
//    link packet
//    waypoint packet
//    link packet
//    ...
//    waypoint packet
//
// The total number of elements in the array (route header packet, link
// packets and waypoint packets) is returned in the "size" argument.

GPS_SWay **Garmin_GPS_Create_A201_Route(Route *pr, int route_number,
                                        int *size) {
  RoutePointList *wplist = pr->pRoutePointList;
  int nPoints = wplist->size();

  // Create the array of GPS_PWays
  // There will be one for the route header, n for each way point
  //  and n-1 for each link

  *size = 1 + nPoints + (nPoints - 1);

  GPS_SWay **ppway = (GPS_SWay **)malloc((*size) * sizeof(GPS_PWay));

  //    and the GPS_Oways themselves
  for (int i = 0; i < *size; i++) ppway[i] = GPS_Way_New();

  //    Now fill in the useful elements

  //    Element 0 is a route record

  GPS_PWay pway = ppway[0];
  pway->isrte = true;
  pway->rte_num = route_number;
  strncpy(pway->rte_ident, (pr->m_RouteNameString.Truncate(255)).mb_str(), 255);
  strncpy(pway->rte_cmnt, (pr->m_RouteNameString.Truncate(19)).mb_str(), 19);

  //    Odd elements 1,3,5... are waypoints
  //    Even elements 2,4,6... are links
  for (int i = 1; i < *size; i++) {
    if (i % 2 == 1) /* Odd */
    {
      GPS_PWay pway = ppway[i];
      auto it = wplist->begin() + i;
      RoutePoint *prp = *it;

      Garmin_GPS_PrepareWptData(pway, prp);
    } else /* Even */
    {
      /* Apparently, 0 filled links are OK */
      GPS_PWay pway = ppway[i];
      pway->islink = true;
      pway->rte_link_class = 0;
      memset(pway->rte_link_subclass, 0, sizeof(pway->rte_link_subclass));
      memset(pway->rte_link_ident, 0, sizeof(pway->rte_link_ident));
    }
  }

  return ppway;
}

int Garmin_GPS_SendRoute(const wxString &port_name, Route *pr,
                         N0183DlgCtx dlg_ctx) {
  int ret_val = 0;

  int route_number = 1;

  //    If the device supports unique numbered waypoints,
  //    Then we must query the device to find an empty number
  if ((gps_rte_hdr_type == pD200) || (gps_rte_hdr_type == pD201)) {
    //    Retrieve <ALL> routes from the device
    GPS_Diag("Garmin: trying to get free route number");
    GPS_PWay *pprouteway;
    int32 npacks = GPS_A200_Get(port_name.mb_str(), &pprouteway);
    if (npacks < 0) return npacks;
    dlg_ctx.set_value(40);

    //  Iterate on the packets, finding the first route number from [0..9] that
    //  is not present

    //    An array of route numbers, set element to true as encountered
    bool brn[10];
    for (int i = 0; i < 10; i++) brn[i] = false;

    for (int ip = 0; ip < npacks; ip++) {
      GPS_PWay pway = pprouteway[ip];
      if (pway->isrte) {
        if ((pway->rte_num < 10)) brn[pway->rte_num] = true;
      }
    }

    //    Find the first candidate within [1..9] that is unused
    bool bfound_empty = false;
    for (int i = 1; i < 10; i++) {
      if (brn[i] == false) {
        route_number = i;
        bfound_empty = true;
        break;
      }
    }
    GPS_Diag("Using route number: %d", route_number);

    //  Ask the user if it is all right to overwrite
    if (!bfound_empty) {
      if (!dlg_ctx.confirm_overwrite()) {
        return 0;
      }
    }
  }

  // Based on the route transfer protocol create the array of transfer packets
  GPS_SWay **ppway;
  int elements = 0;
  if (gps_route_transfer == pA201)
    ppway = Garmin_GPS_Create_A201_Route(pr, route_number, &elements);
  else
    ppway = Garmin_GPS_Create_A200_Route(pr, route_number, &elements);

  //    Transmit the Route to the GPS receiver
  int xfer_result = GPS_Command_Send_Route(port_name.mb_str(), ppway, elements);
  ret_val = xfer_result;

  //  Free all the memory
  for (int i = 0; i < elements; i++) GPS_Way_Del(&ppway[i]);

  free(ppway);
  dlg_ctx.set_value(80);

  VerifyPortClosed();
  return ret_val;
}

/*
int Garmin_USB_On()
{
      int ret_val = GPS_Device_On("usb:", &my_gps_devh);

      return ret_val;
}

int Garmin_USB_Off()
{
      int ret_val = GPS_Device_Off(my_gps_devh);

      return ret_val;
}
*/
