/* This file is part of Zutty.
 * Copyright (C) 2020 Tom Szilagyi
 *
 * 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.
 *
 * See the file LICENSE for the full license.
 */

#include "frame.h"
#include "log.h"

namespace zutty
{
   Frame::Frame () {}

   Frame::Frame (uint16_t winPx_, uint16_t winPy_,
                 uint16_t nCols_, uint16_t nRows_,
                 uint16_t& marginTop_, uint16_t& marginBottom_,
                 uint16_t saveLines_)
      : winPx (winPx_)
      , winPy (winPy_)
      , nCols (nCols_)
      , nRows (nRows_)
      , saveLines (saveLines_)
      , scrollHead (0)
      , marginTop (0)
      , marginBottom (nRows + saveLines)
      , historyRows (0)
      , viewOffset (0)
      , margins (false)
      , cells (CharVdev::make_cells (nCols, nRows + saveLines))
   {
      marginTop_ = marginTop;
      marginBottom_ = nRows;
      damage.totalCells = nCols * (nRows + saveLines);
      highMemUsageReport ();
   }

   void
   Frame::dropScrollbackHistory ()
   {
      viewOffset = 0;
      historyRows = 0;
      expose ();
   }

   void
   Frame::setMargins (uint16_t marginTop_, uint16_t marginBottom_)
   {
      unwrapCellStorage ();
      scrollHead = marginTop = marginTop_;
      marginBottom = marginBottom_;
      margins = true;
      expose ();
   }

   void
   Frame::resetMargins (uint16_t& marginTop_, uint16_t& marginBottom_)
   {
      unwrapCellStorage ();
      scrollHead = marginTop = marginTop_ = 0;
      marginBottom = nRows + saveLines;
      marginBottom_ = nRows;
      margins = false;
      expose ();
   }

   void
   Frame::resize (uint16_t winPx_, uint16_t winPy_,
                  uint16_t nCols_, uint16_t nRows_,
                  uint16_t& marginTop_, uint16_t& marginBottom_)
   {
      if (winPx == winPx_ && winPy == winPy_)
         return;

      winPx = winPx_;
      winPy = winPy_;

      if (nCols == nCols_ && nRows == nRows_)
         return;

      auto newCells = CharVdev::make_cells (nCols_, nRows_ + saveLines);
      CharVdev::Cell* dst = newCells.get ();

      const int rowLen = std::min (nCols, nCols_);
      const int nCopyRows = std::min (nRows, nRows_);
      CharVdev::Cell* p = dst;
      for (int pY = 0; pY < nCopyRows; ++pY)
      {
         memcpy (p, getPhysRowPtr (pY), rowLen * cellSize);
         p += nCols_;
      }
      p = dst + (nRows_ + saveLines - historyRows) * nCols_;
      for (int pY = -historyRows; pY < 0; ++pY)
      {
         memcpy (p, getPhysRowPtr (pY), rowLen * cellSize);
         p += nCols_;
      }

      cells = std::move (newCells);
      nCols = nCols_;
      nRows = nRows_;
      scrollHead = 0;
      marginTop = marginTop_ = 0;
      marginBottom_ = nRows;
      marginBottom = nRows + saveLines;
      margins = false;
      viewOffset = 0;
      damage.totalCells = nCols * (nRows + saveLines);
      highMemUsageReport ();
   }

   void
   Frame::fullCopyCells (CharVdev::Cell * const dst)
   {
      CharVdev::Cell* p = dst;
      for (int pY = 0; pY < nRows; ++pY)
      {
         memcpy (p, getViewRowPtr (pY), nCols * cellSize);
         p += nCols;
      }
   }

   void
   Frame::deltaCopyCells (CharVdev::Cell * const dst)
   {
      CharVdev::Cell* p = dst;
      for (int pY = -viewOffset; pY < nRows - viewOffset; ++pY)
      {
         damageDeltaCopy (p, nCols * getPhysicalRow (pY), nCols);
         p += nCols;
      }
   }

   Rect
   Frame::getSnappedSelection () const
   {
      Rect ret = selection;

      if (ret.null ())
         return ret;

      if (selection.rectangular)
         return ret;

      switch (snapTo)
      {
      case SelectSnapTo::Char:
         break;
      case SelectSnapTo::Word:
      {
         const auto* cp = getViewRowPtr (ret.tl.y);
         while (ret.tl.x < nCols && cp [ret.tl.x].uc_pt == ' ')
            ++ret.tl.x;
         while (ret.tl.x > 0 && cp [ret.tl.x - 1].uc_pt != ' ')
            --ret.tl.x;

         cp = getViewRowPtr (ret.br.y);
         while (ret.br.x > 0 && cp [ret.br.x].uc_pt == ' ')
            --ret.br.x;
         while (ret.br.x < nCols && cp [ret.br.x].uc_pt != ' ')
            ++ret.br.x;
      }
         break;
      case SelectSnapTo::Line:
         ret.tl.x = 0;
         ret.br.x = nCols;
         break;
      default: break;
      }

      return ret;
   }

   bool
   Frame::getSelectedUtf8 (std::string& utf8_selection) const
   {
      const Rect sel = getSnappedSelection ();

      if (sel.empty ())
         return false;

      using utf16str = std::vector <uint16_t>;
      std::vector <utf16str> lines;
      bool wrap = false;

      // save lines from the selected range of the frame cell buffer
      auto addLine =
         [&] (int y, uint16_t x1, uint16_t x2)
         {
            utf16str line;
            bool wrapBack = wrap;
            wrap = false;
            const auto* cp = getViewRowPtr (y);
            for (uint16_t x = x1; x < x2; ++x)
            {
               const auto& cell = cp [x];
               if (!cell.dwidth_cont)
                  line.push_back (cell.uc_pt);
               if (cell.wrap)
               {
                  wrap = true;
                  break;
               }
            }

            while (!wrap && line.size () && line.back () == ' ')
               line.pop_back (); // discard trailing whitespace

            if (wrapBack && lines.size ())
               lines.back ().insert (lines.back ().end (),
                                     line.begin (), line.end ());
            else
               lines.push_back (line);
         };

      if (sel.tl.y == sel.br.y)
      {
         addLine (sel.tl.y, sel.tl.x, sel.br.x);
      }
      else if (sel.rectangular)
      {
         for (int y = sel.tl.y; y <= sel.br.y; ++y)
            addLine (y, sel.tl.x, sel.br.x);
      }
      else
      {
         addLine (sel.tl.y, sel.tl.x, nCols);
         for (int y = sel.tl.y + 1; y < sel.br.y; ++y)
            addLine (y, 0, nCols);
         addLine (sel.br.y, 0, sel.br.x);
      }

      // convert to UTF-8
      std::vector <char> utf8_out;
      auto sinkFn = [&] (char ch) { utf8_out.push_back (ch); };
      for (const auto& u16s: lines)
      {
         for (uint16_t cp: u16s)
            Utf8Encoder::pushUnicode (cp, sinkFn);
         utf8_out.push_back ('\n');
      }
      while (utf8_out.size () && utf8_out.back () == '\n')
         utf8_out.pop_back (); // discard trailing empty lines

      utf8_selection = std::string (utf8_out.data (), utf8_out.size ());

   #if DEBUG
      if (utf8_selection.size () <= 80)
         logT << "Selected " << utf8_selection.size () << " bytes:\n'"
              << utf8_selection << "'" << std::endl;
      else
         logT << "Selected " << utf8_selection.size () << " bytes:\n'"
              << utf8_selection.substr (0, 40) << "' ...\n'"
              << utf8_selection.substr (utf8_selection.size () - 40) << "'"
              << std::endl;
   #endif // DEBUG
      return true;
   }

   // private functions

   inline void
   Frame::damageDeltaCopy (CharVdev::Cell* dst, uint32_t start, uint32_t count)
   {
      uint32_t end = start + count;

      if (damage.end <= start || end <= damage.start)
         return; // no intersection

      if (start < damage.start)
      {
         dst += (damage.start - start);
         start = damage.start;
      }

      if (damage.end < end)
      {
         end = damage.end;
      }

      CharVdev::Cell* const src = cells.get ();

      for (size_t i = 0, j = start; j < end; ++i, ++j)
      {
         if (dst [i] != src [j])
         {
            dst [i] = src [j];
            dst [i].dirty = 1;
         }
      }
   }

   void
   Frame::copyAllCells (CharVdev::Cell * const dst)
   {
      CharVdev::Cell* p = dst;
      for (int pY = 0; pY < nRows; ++pY)
      {
         memcpy (p, getPhysRowPtr (pY), nCols * cellSize);
         p += nCols;
      }
      p = dst + (nRows + saveLines - historyRows) * nCols;
      for (int pY = -historyRows; pY < 0; ++pY)
      {
         memcpy (p, getPhysRowPtr (pY), nCols * cellSize);
         p += nCols;
      }
   }

   void
   Frame::unwrapCellStorage ()
   {
      if (scrollHead == marginTop)
         return;

      auto newCells = CharVdev::make_cells (nCols, nRows + saveLines);
      copyAllCells (newCells.get ());
      cells = std::move (newCells);
      scrollHead = marginTop;
   }

   void
   Frame::highMemUsageReport ()
   {
      auto allocKB = damage.totalCells * cellSize / 1024;
      if (allocKB > 8192)
      {
         logI << "Allocated " << allocKB << " KiB for cell storage; consider "
              << "decreasing saveLines (current value: " << saveLines
              << ") to reduce memory usage!"
              << std::endl;
      }
   }

} // namespace zutty