/* 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 "log.h"
#include "options.h"
#include "selmgr.h"

#include <X11/Xmu/Atoms.h>

namespace zutty
{
   SelectionManager::SelectionManager (Display* dpy_, Window win_)
      : dpy (dpy_)
      , win (win_)
      , primary (XA_PRIMARY)
      , clipboard (XA_CLIPBOARD (dpy))
      , incr (XInternAtom (dpy, "INCR", False))
      , prop (XInternAtom(dpy, "_ZUTTY_SELECTION", False))
      , target (XA_UTF8_STRING (dpy))
      , targets (XInternAtom (dpy, "TARGETS", False))
      , chunkSize (XExtendedMaxRequestSize (dpy)
                   ? XExtendedMaxRequestSize (dpy) >> 2
                   : XMaxRequestSize (dpy) >> 2)
   {
      // N.B.: create map entries:
      ctx [primary].content = "";
      ctx [clipboard].content = "";

      logT << "SelectionManager: chunkSize=" << chunkSize << std::endl;
   }

   void
   SelectionManager::getSelection (Atom selection,
                                   Time time, PasteCallbackFn&& cb)
   {
      Context& cx = ctx [selection];

      if (cx.owned)
      {
         cb (true, cx.content);
         return;
      }

      cx.incoming.clear ();
      cx.pasteCallback = cb;
      XConvertSelection (dpy, selection, target, prop, win, time);
      cx.state = State::WaitingForSelNotify;
   }

   bool
   SelectionManager::setSelection (Atom selection,
                                   Time time, const std::string& content_)
   {
      Context& cx = ctx [selection];

      XSetSelectionOwner(dpy, selection, win, time);
      if (XGetSelectionOwner (dpy, selection) == win)
      {
         cx.content = content_;
         cx.owned = true;
      }
      else
      {
         cx.owned = false;
      }
      return cx.owned;
   }

   bool
   SelectionManager::copySelection (Atom dest, Atom source)
   {
      Context& cx = ctx [source];

      if (! cx.owned)
         return false;

      return setSelection (dest, CurrentTime, cx.content);
   }

   void
   SelectionManager::handleInboundIncr (Context& cx)
   {
      // Receive next chunk of ongoing INCR transfer
      Atom type = None;
      int propFormat;
      unsigned long propSize, propItems;
      unsigned char* buffer;
      XGetWindowProperty (dpy, win, prop, 0, 0, False, AnyPropertyType,
                          &type, &propFormat, &propItems, &propSize,
                          &buffer);
      XFree (buffer);

      if (propSize == 0) {
         // no more data, exit from loop
         XDeleteProperty (dpy, win, prop);
         cx.state = State::Idle;

         logT << "Received INCR end of transfer" << std::endl;
         cx.pasteCallback (true, std::string ((char *) cx.incoming.data (),
                                              cx.incoming.size ()));
         cx.incoming.clear ();
         return;
      }

      // the property contains text of known size
      XGetWindowProperty (dpy, win, prop, 0, propSize, False,
                          AnyPropertyType, &type, &propFormat, &propItems,
                          &propSize, &buffer);

      logT << "Received INCR data size=" << propSize
           << " format=" << propFormat
           << " items=" << propItems
           << " bytes=" << (propFormat >> 3) * propItems
           << std::endl;
      size_t len = (propFormat >> 3) * propItems;
      size_t pos = cx.incoming.size ();
      cx.incoming.resize (pos + len);
      memcpy (cx.incoming.data () + pos, buffer, len);

      XFree (buffer);

      // delete property to get the next chunk
      XDeleteProperty (dpy, win, prop);
      XFlush (dpy);
   }

   void
   SelectionManager::handleOutboundIncr (Context& cx)
   {
      // Send next chunk of ongoing INCR transfer
      size_t len = std::min (chunkSize, cx.content.length () - cx.cliPos);
      if (len > 0)
      {
         logT << "Sending next INCR chunk..." << std::endl;
         XChangeProperty (dpy, cx.cliWin, cx.cliProp, target, 8, PropModeReplace,
                          (const unsigned char *) cx.content.data () + cx.cliPos,
                          len);
      }
      else
      {
         logT << "Signaling end of INCR transfer..." << std::endl;
         XChangeProperty (dpy, cx.cliWin, cx.cliProp, target, 8, PropModeReplace,
                          nullptr, 0);
         cx.state = State::Idle;
      }
      XFlush (dpy);
      cx.cliPos += len;
   }

   void
   SelectionManager::onPropertyNotify (XPropertyEvent& event)
   {
      logT << "onPropertyNotify"
           << " on '" << XGetAtomName (dpy, event.atom) << "' "
           << (event.state == PropertyNewValue ? "(NewValue)" : "(Delete)")
           << std::endl;

      Context& cxp = ctx [primary];
      Context& cxc = ctx [clipboard];

      if (event.state == PropertyDelete)
      {
         if (cxp.state == State::WaitingForIncrAck &&
             cxp.cliProp == event.atom)
         {
            handleOutboundIncr (cxp);
         }
         else if (cxc.state == State::WaitingForIncrAck &&
                  cxc.cliProp == event.atom)
         {
            handleOutboundIncr (cxc);
         }
      }
      else if (event.state == PropertyNewValue && event.atom == prop)
      {
         if (cxp.state == State::ReadingIncr)
            handleInboundIncr (cxp);
         else if (cxc.state == State::ReadingIncr)
            handleInboundIncr (cxc);
      }
   }

   void
   SelectionManager::onSelectionClear (XSelectionClearEvent& event)
   {
      logT << "onSelectionClear for " << XGetAtomName (dpy, event.selection)
           << std::endl;

      if (ctx.find (event.selection) == ctx.end ())
      {
         logE << "No selection state for "
              << XGetAtomName (dpy, event.selection) << std::endl;
         return;
      }

      ctx [event.selection].owned = false;
      ctx [event.selection].content = "";
   }

   void
   SelectionManager::onSelectionNotify (XSelectionEvent& event)
   {
      logT << "onSelectionNotify for " << XGetAtomName (dpy, event.selection)
           << std::endl;

      if (ctx.find (event.selection) == ctx.end ())
      {
         logE << "No selection state for "
              << XGetAtomName (dpy, event.selection) << std::endl;
         return;
      }

      Context& cx = ctx [event.selection];

      if (cx.state != State::WaitingForSelNotify)
      {
         logW << "Ignoring XSelectionEvent in state=" << (int)cx.state
              << std::endl;
         return;
      }

      if (event.property == None) {
         logW << "Conversion to requested target '"
              << XGetAtomName (dpy, target) << "' failed." << std::endl;
         cx.pasteCallback (false, "");
         cx.state = State::Idle;
         return;
      }

      // find the size and format of the data in property
      Atom type = None;
      int propFormat;
      unsigned long propSize, propItems;
      unsigned char* buffer;
      XGetWindowProperty (dpy, win, prop, 0, 0, False, AnyPropertyType,
                          &type, &propFormat, &propItems, &propSize, &buffer);
      XFree (buffer);

      if (type == incr) {
         logT << "Starting INCR by deleting property" << std::endl;
         XDeleteProperty (dpy, win, prop);
         XFlush (dpy);
         cx.state = State::ReadingIncr;
         return;
      }

      // not using INCR mechanism, just read the property
      XGetWindowProperty (dpy, win, prop, 0, propSize, False,
                          AnyPropertyType, &type, &propFormat, &propItems,
                          &propSize, &buffer);
      XDeleteProperty (dpy, win, prop);

      logT << "Received data size=" << propSize
           << " format=" << propFormat
           << " items=" << propItems
           << " bytes=" << (propFormat >> 3) * propItems
           << std::endl;
      size_t len = (propFormat >> 3) * propItems;
      size_t pos = cx.incoming.size ();
      cx.incoming.resize (pos + len);
      memcpy (cx.incoming.data () + pos, buffer, len);
      cx.pasteCallback (true, std::string ((char *) cx.incoming.data (),
                                           cx.incoming.size ()));
      cx.incoming.clear ();

      XFree (buffer);
      cx.state = State::Idle;
   }

   void
   SelectionManager::onSelectionRequest (XSelectionRequestEvent& event)
   {
      logT << "onSelectionRequest for " << XGetAtomName (dpy, event.selection)
           << std::endl;

      if (ctx.find (event.selection) == ctx.end ())
      {
         logE << "No selection state for "
              << XGetAtomName (dpy, event.selection) << std::endl;
         return;
      }

      Context& cx = ctx [event.selection];

      if (cx.state != State::Idle)
      {
         logW << "Ignoring XSelectionRequestEvent in state=" << (int)cx.state
              << std::endl;
         return;
      }

      if (! cx.owned)
      {
         logW << "Ignoring selection request for "
              << XGetAtomName (dpy, event.selection)
              << " that we do not own."
              << std::endl;
         return;
      }

      cx.cliWin = event.requestor;
      cx.cliProp = event.property;
      cx.cliPos = 0;

      if (event.target == targets) // response to TARGETS request
      {
         Atom types [2] = { targets, target };
         XChangeProperty (dpy, cx.cliWin, cx.cliProp, XA_ATOM, 32,
                          PropModeReplace, (const unsigned char *) types, 2);
      }
      else if (chunkSize < cx.content.size ()) // INCR response
      {
         logT << "Sending INCR response" << std::endl;
         XChangeProperty (dpy, cx.cliWin, cx.cliProp, incr, 32,
                          PropModeReplace, nullptr, 0);
         XSelectInput (dpy, cx.cliWin, PropertyChangeMask);
         cx.state = State::WaitingForIncrAck;
      }
      else // normal response (send all data)
      {
         logT << "Sending normal response" << std::endl;
         XChangeProperty (dpy, cx.cliWin, cx.cliProp, target, 8,
                          PropModeReplace,
                          (const unsigned char *) cx.content.data (),
                          cx.content.size ());
      }

      // send SelectionNotify event in response
      {
         XEvent res;
         res.xselection.type = SelectionNotify;
         res.xselection.property = cx.cliProp;
         res.xselection.display = event.display;
         res.xselection.requestor = cx.cliWin;
         res.xselection.selection = event.selection;
         res.xselection.target = event.target;
         res.xselection.time = event.time;
         XSendEvent (dpy, event.requestor, 0, 0, &res);
         XFlush (dpy);
      }
   }

} // namespace zutty