/*
* Descent 3
* Copyright (C) 2024 Parallax Software
*
* 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 3 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 <http://www.gnu.org/licenses/>.

--- HISTORICAL COMMENTS FOLLOW ---

 * $Logfile: /DescentIII/Main/editor/EPath.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:38 $
 * $Author: kevinb $
 *
 * Code to create & modify paths
 *
 * $Log: not supported by cvs2svn $
 *
 * 13    8/20/99 9:43p Gwar
 * changes to InsertNodeIntoPath and DrawAllPaths for NEWEDITOR
 *
 * 12    8/18/99 7:00a Gwar
 * changes to add EPath.cpp to NEWEDITOR project
 *
 * 11    4/18/99 5:42a Chris
 * Added the FQ_IGNORE_RENDER_THROUGH_PORTALS flag
 *
 * 10    2/26/99 6:14p Matt
 * Made new nodes go at the viewer position instead of in front of it, and
 * make the selected path draw in a different color than the others.
 *
 * 9     2/26/99 12:40p Matt
 * Changed occluded messages to (hopefully) be more understandable
 *
 * 8     2/26/99 12:26p Matt
 * Fixed spelling error.
 *
 * 7     2/18/99 2:01p Dan
 * Fixed outside/inside problem
 *
 * 6     2/08/99 3:29p Chris
 * Added a no orient move for objects
 *
 * 5     2/03/99 6:56p Chris
 * Added the "Move node to current object" function
 *
 * 4     10/14/98 2:48p Kevin
 * Changed memory code to comply with mem lib
 *
 * 3     5/03/98 8:36p Chris
 * Additional debug info
 *
 * 2     2/10/98 10:48a Matt
 * Moved editor code from gamepath.cpp to epath.cpp
 *
 * 1     2/10/98 10:13a Matt
 *
 */

#include <memory.h>

#ifndef NEWEDITOR
#include "d3edit.h"
#else
#include "globals.h"
#include "terrain.h"
#include "renderer.h"
#endif

#include "epath.h"
#include "mono.h"
#include "object.h"
#include "findintersection.h"

uint8_t Show_paths = 1;

// Allocs a gamepath that a robot will follow.  Returns an index into the GamePaths
// array
int AllocGamePath() {
  int i;

  if (Viewer_object->flags & OF_OUTSIDE_MINE) {
    OutrageMessageBox("You must be in a room or on the terrain to create a path");
    return -1;
  }

  for (i = 0; i < MAX_GAME_PATHS; i++) {
    if (GamePaths[i].used == 0) {
      GamePaths[i].used = 1;
      GamePaths[i].name[0] = 0;
      GamePaths[i].num_nodes = 0;
      GamePaths[i].flags = 0;

      GamePaths[i].pathnodes = (node *)mem_malloc(MAX_NODES_PER_PATH * sizeof(node));
      mprintf(0, "Path %d got some\n", i);

      Num_game_paths++;
      return i;
    }
  }

  OutrageMessageBox("ERROR: Too many paths to add another.");
  return -1;
}

int MovePathNode(int pathnum, int nodenum, vector *delta_pos) {
  vector attempted_pos = GamePaths[pathnum].pathnodes[nodenum].pos + *delta_pos;

  return MovePathNodeToPos(pathnum, nodenum, &attempted_pos);
}

int MovePathNodeToPos(int pathnum, int nodenum, vector *attempted_pos) {
  fvi_query fq;
  fvi_info hit_info;

  fq.p0 = &GamePaths[pathnum].pathnodes[nodenum].pos;
  fq.startroom = GamePaths[pathnum].pathnodes[nodenum].roomnum;
  fq.p1 = attempted_pos;
  fq.rad = 0.0f;
  fq.thisobjnum = -1;
  fq.ignore_obj_list = NULL;
  fq.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;

  fvi_FindIntersection(&fq, &hit_info);

  // Check if new node is valid
  if (nodenum >= 1) {
    fvi_query fq1;
    fvi_info hit_info1;

    fq1.p0 = &GamePaths[pathnum].pathnodes[nodenum - 1].pos;
    fq1.startroom = GamePaths[pathnum].pathnodes[nodenum - 1].roomnum;
    fq1.p1 = &hit_info.hit_pnt;
    fq1.rad = 0.0f;
    fq1.thisobjnum = -1;
    fq1.ignore_obj_list = NULL;
    fq1.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;

    fvi_FindIntersection(&fq1, &hit_info1);
    if (vm_VectorDistance(&hit_info.hit_pnt, &hit_info1.hit_pnt) > .005) {
      OutrageMessageBox("Cannot move point.  There is no line of sight from the previous node to the new position.");
      return -1;
    }
  }

  // Check if new node is valid
  if (nodenum < GamePaths[pathnum].num_nodes - 1) {
    fvi_query fq1;
    fvi_info hit_info1;

    fq1.p0 = &GamePaths[pathnum].pathnodes[nodenum + 1].pos;
    fq1.startroom = GamePaths[pathnum].pathnodes[nodenum + 1].roomnum;
    fq1.p1 = &hit_info.hit_pnt;
    fq1.rad = 0.0f;
    fq1.thisobjnum = -1;
    fq1.ignore_obj_list = NULL;
    fq1.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;

    fvi_FindIntersection(&fq1, &hit_info1);
    if (vm_VectorDistance(&hit_info.hit_pnt, &hit_info1.hit_pnt) > .005) {
      OutrageMessageBox("Cannot move point.  There is no line of sight from the next node to the new position.");
      return -1;
    }
  }

  GamePaths[pathnum].pathnodes[nodenum].pos = hit_info.hit_pnt;
  GamePaths[pathnum].pathnodes[nodenum].roomnum = hit_info.hit_room;

  return 0;
}

// Given a path number, and a node number in that path, adds another node after the
// specified node
// Returns the index number of the new node
// If nodenum is -1, this node was not added
// roomnum is only valid if this is the first node in a room
#ifndef NEWEDITOR
int InsertNodeIntoPath(int pathnum, int nodenum, int flags)
#else
int InsertNodeIntoPath(int pathnum, int nodenum, int flags, int roomnum, vector pos, matrix orient)
#endif
{
  int i;
  vector attempted_pos;

  fvi_query fq;
  fvi_info hit_info;

  if (Viewer_object->flags & OF_OUTSIDE_MINE) {
    OutrageMessageBox("Error: Must be in mine or on terrain to insert a node.");
    return -1;
  }

  if (GamePaths[pathnum].num_nodes >= MAX_NODES_PER_PATH) {
    OutrageMessageBox("Error: Path already has its maximum amount of nodes.");
    return -1;
  }

  // First, move all nodes up one
  for (i = GamePaths[pathnum].num_nodes - 1; i > nodenum; i--) {
    memcpy(&GamePaths[pathnum].pathnodes[i + 1], &GamePaths[pathnum].pathnodes[i], sizeof(node));
  }

#ifndef NEWEDITOR
  attempted_pos = Viewer_object->pos; // + Viewer_object->orient.fvec * 10.0;
#else
  attempted_pos = pos; // + Viewer_object->orient.fvec * 10.0;
#endif

#ifndef NEWEDITOR
  fq.p0 = &Viewer_object->pos;
  fq.startroom = Viewer_object->roomnum;
#else
  fq.p0 = &pos;
  fq.startroom = roomnum;
#endif
  fq.p1 = &attempted_pos;
  fq.rad = 0.0f;
  fq.thisobjnum = -1;
  fq.ignore_obj_list = NULL;
  fq.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;

  fvi_FindIntersection(&fq, &hit_info);

  // Check if new node is valid
  if (nodenum >= 0) {
    fvi_query fq1;
    fvi_info hit_info1;

    fq1.p0 = &GamePaths[pathnum].pathnodes[nodenum].pos;
    fq1.startroom = GamePaths[pathnum].pathnodes[nodenum].roomnum;
    fq1.p1 = &hit_info.hit_pnt;
    fq1.rad = 0.0f;
    fq1.thisobjnum = -1;
    fq1.ignore_obj_list = NULL;
    fq1.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;

    fvi_FindIntersection(&fq1, &hit_info1);
    if (vm_VectorDistance(&hit_info.hit_pnt, &hit_info1.hit_pnt) > .005) {
      OutrageMessageBox("Cannot add new point.  There is no line of sight from the previous node.");
      return -1;
    }
  }

  // Check if new node is valid
  if (nodenum >= 0 && nodenum < GamePaths[pathnum].num_nodes - 1) {
    fvi_query fq1;
    fvi_info hit_info1;

    fq1.p0 = &GamePaths[pathnum].pathnodes[nodenum + 1].pos;
    fq1.startroom = GamePaths[pathnum].pathnodes[nodenum + 1].roomnum;
    fq1.p1 = &hit_info.hit_pnt;
    fq1.rad = 0.0f;
    fq1.thisobjnum = -1;
    fq1.ignore_obj_list = NULL;
    fq1.flags = FQ_TRANSPOINT | FQ_IGNORE_RENDER_THROUGH_PORTALS;

    fvi_FindIntersection(&fq1, &hit_info1);
    if (vm_VectorDistance(&hit_info.hit_pnt, &hit_info1.hit_pnt) > .005) {
      OutrageMessageBox("Cannot add new point.  There is no line of sight from the next node.");
      return -1;
    }
  }

  int newnode = nodenum + 1;

  GamePaths[pathnum].pathnodes[newnode].pos = hit_info.hit_pnt;
  GamePaths[pathnum].pathnodes[newnode].roomnum = hit_info.hit_room;

#ifndef NEWEDITOR
  GamePaths[pathnum].pathnodes[newnode].fvec = Viewer_object->orient.fvec;
  GamePaths[pathnum].pathnodes[newnode].uvec = Viewer_object->orient.uvec;
#else
  GamePaths[pathnum].pathnodes[newnode].fvec = orient.fvec;
  GamePaths[pathnum].pathnodes[newnode].uvec = orient.uvec;
#endif

  GamePaths[pathnum].num_nodes++;

  GamePaths[pathnum].pathnodes[newnode].flags = flags;

  return newnode;
}

// Given a pathnum and a node index, deletes that node and moves all the following nodes down
// by one
void DeleteNodeFromPath(int pathnum, int nodenum) {
  int i;

  // First, move all nodes up one
  for (i = nodenum; i < GamePaths[pathnum].num_nodes - 1; i++) {
    memcpy(&GamePaths[pathnum].pathnodes[i], &GamePaths[pathnum].pathnodes[i + 1], sizeof(node));
  }

  GamePaths[pathnum].num_nodes--;
}

// Gets next path from n that has actually been alloced
int GetNextPath(int n) {
  int i;

  ASSERT(n >= 0 && n < MAX_GAME_PATHS);

  if (Num_game_paths == 0)
    return -1;

  for (i = n + 1; i < MAX_GAME_PATHS; i++)
    if (GamePaths[i].used)
      return i;
  for (i = 0; i < n; i++)
    if (GamePaths[i].used)
      return i;

  // this is the only one

  return n;
}

// Gets previous path from n that has actually been alloced
int GetPrevPath(int n) {
  int i;

  ASSERT(n >= 0 && n < MAX_GAME_PATHS);

  if (Num_game_paths == 0)
    return -1;

  for (i = n - 1; i >= 0; i--) {
    if (GamePaths[i].used)
      return i;
  }
  for (i = MAX_GAME_PATHS - 1; i > n; i--) {
    if (GamePaths[i].used)
      return i;
  }

  // this is the only one
  return n;
}

// returns the index of the first path (from 0) alloced
// returns -1 if there are no paths
int GetFirstPath() {
  int i;
  for (i = 0; i < MAX_GAME_PATHS; i++) {
    if (GamePaths[i].used)
      return i;
  }
  return -1;
}

#ifndef NEWEDITOR
#include "editor/d3edit.h"
#endif

#include "gr.h"

void DrawAllPaths(grViewport *vp, vector *viewer_eye, matrix *viewer_orient, float zoom) {
  int i, current_path_index = 0, t;
  g3Point rot_points[300];
  int sort_index[300];

  if (!Show_paths)
    return;

  current_path_index = GetFirstPath();

  for (i = 0; i < Num_game_paths; i++, current_path_index = GetNextPath(current_path_index)) {

    game_path *gp = &GamePaths[current_path_index];

#ifndef NEWEDITOR
    int curnode = D3EditState.current_node;
#else
    int curnode = Editor_state.GetCurrentNode();
#endif

    for (t = 0; t < gp->num_nodes; t++) {
      g3_RotatePoint(&rot_points[t], &gp->pathnodes[t].pos);
      sort_index[t] = t;
    }

#ifndef NEWEDITOR
    ddgr_color path_color =
        (current_path_index == D3EditState.current_path) ? GR_RGB(255, 255, 255) : GR_RGB(36, 99, 238);
#else
    ddgr_color path_color =
        (current_path_index == Editor_state.GetCurrentPath()) ? GR_RGB(255, 255, 255) : GR_RGB(36, 99, 238);
#endif

    for (t = 0; t < gp->num_nodes - 1; t++) {
      g3Point p1 = rot_points[t];
      g3Point p2 = rot_points[t + 1];

      g3_DrawLine(path_color, &p1, &p2);
    }

    for (t = 0; t < gp->num_nodes; t++) {
      for (int k = 0; k < gp->num_nodes; k++) {
        if (rot_points[k].p3_vec.z < rot_points[t].p3_vec.z) {
          g3Point temp;
          int tindex;

          memcpy(&temp, &rot_points[t], sizeof(g3Point));
          memcpy(&rot_points[t], &rot_points[k], sizeof(g3Point));
          memcpy(&rot_points[k], &temp, sizeof(g3Point));

          tindex = sort_index[t];
          sort_index[t] = sort_index[k];
          sort_index[k] = tindex;
        }
      }
    }

    for (t = 0; t < gp->num_nodes; t++) {
      int color;
      float size;

#ifdef NEWEDITOR
      ddgr_color oldcolor;

      if (TSearch_on) {
        rend_SetPixel(GR_RGB(16, 255, 16), TSearch_x, TSearch_y);
        oldcolor = rend_GetPixel(TSearch_x, TSearch_y);
      }
#endif

#ifndef NEWEDITOR
      if (current_path_index == D3EditState.current_path && curnode == sort_index[t])
#else
      if (current_path_index == Editor_state.GetCurrentPath() && curnode == sort_index[t])
#endif
      {
        color = GR_RGB(100, 128, 255);
        size = 1.2f;
      } else {
        color = GR_RGB(0, 128, 160);
        size = 1.2f;
      }

      g3_DrawSphere(color, &rot_points[t], size);

      vector fpos = gp->pathnodes[sort_index[t]].pos + gp->pathnodes[sort_index[t]].fvec * (size - size / 10.0);
      vector upos = gp->pathnodes[sort_index[t]].pos + gp->pathnodes[sort_index[t]].uvec * (size - size / 10.0);

      g3Point frot;
      g3Point urot;

      g3_RotatePoint(&frot, &fpos);
      g3_RotatePoint(&urot, &upos);

      g3_DrawLine(GR_RGB(0, 255, 0), &rot_points[t], &frot);
      g3_DrawLine(GR_RGB(0, 0, 255), &rot_points[t], &urot);
      g3_DrawSphere(GR_RGB(0, 255, 0), &frot, size / 10.0);
      g3_DrawSphere(GR_RGB(0, 0, 255), &urot, size / 10.0);

#ifdef NEWEDITOR
      if (TSearch_on) {
        if (rend_GetPixel(TSearch_x, TSearch_y) != oldcolor) {
          TSearch_found_type = TSEARCH_FOUND_NODE;
          TSearch_seg = current_path_index;
          TSearch_face = sort_index[t];
        }
      }
#endif

      DrawNumber(sort_index[t] + 1, gp->pathnodes[sort_index[t]].pos, size * .5);
    }
  }
}

static float ArrayX[10][20] = {{-1, 1, 1, -1, -1},
                               {-.25, 0.0, 0.0, 0.0, -1.0, 1.0},
                               {-1.0, 1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0},
                               {-1.0, 1.0, 1.0, -1.0, 1.0, 1.0, -.5},
                               {-1.0, -1.0, -1.0, 1.0, 1.0, 1.0},
                               {-1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, 1.0},
                               {-1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, 1.0},
                               {-1.0, 1.0, 1.0, 1.0},
                               {-1.0, 1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0},
                               {1.0, -1.0, -1.0, 1.0, 1.0, 1.0}};

static float ArrayY[10][20] = {{1, 1, -1, -1, 1},
                               {.75, 1.0, 1.0, -1.0, -1.0, -1.0},
                               {1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, -1.0, -1.0},
                               {1.0, 1.0, -1.0, -1.0, -1.0, 0, 0.0},
                               {1.0, 0.0, 0.0, 0.0, 1.0, -1.0},
                               {1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, -1.0, -1.0},
                               {1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0},
                               {1.0, 1.0, 1.0, -1.0},
                               {1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, 0.0, 0.0},
                               {1.0, 1.0, 0.0, 0.0, 1.0, -1.0}};

static int NumOfPoints[] = {5, 6, 10, 7, 6, 10, 10, 4, 10, 6};

void DrawNumber(int num, vector pos, float size) {
  g3Point basepnt, rot_pnt[20];
  int num_array[10];
  int i, j;
  int total = num;
  size /= 2;

  if (num < 0) {
    return;
  }

  int num_numbers = log10(num) + 1;
  if (num_numbers > 10) {
    mprintf(0, "Cannot represent a number with over 10 digits\n");
    Int3();
    return;
  }

  for (j = num_numbers - 1; j >= 0; j--) {
    num_array[j] = total / (pow(10, j));
    total -= num_array[j] * pow(10, j);
  }

  for (j = 0; j < num_numbers; j++) {
    vector cur_pos;

    if (num_numbers & 0x00000001)
      cur_pos = pos + (2.1 * size * ((num_numbers >> 1) - j)) * Viewer_object->orient.rvec;
    else
      cur_pos = pos + (2.1 * size * ((num_numbers >> 1) - j) - size) * Viewer_object->orient.rvec;

    g3_RotatePoint(&basepnt, &cur_pos);

    for (i = 0; i < NumOfPoints[num_array[j]]; i++) {
      rot_pnt[i] = basepnt;

      rot_pnt[i].p3_vec.x += (ArrayX[num_array[j]][i] * size);
      rot_pnt[i].p3_vec.y += (ArrayY[num_array[j]][i] * size);

      rot_pnt[i].p3_flags = 0;
      g3_CodePoint(&rot_pnt[i]);
      g3_ProjectPoint(&rot_pnt[i]);
    }

    for (i = 0; i < NumOfPoints[num_array[j]] - 1; i++) {
      g3Point p1, p2;

      p1 = rot_pnt[i];
      p2 = rot_pnt[i + 1];

      g3_DrawLine(GR_RGB(255, 255, 255), &p1, &p2);
    }
  }
}