/***************************************************************************

    source::worx xtree
    Copyright © 2024-2025 c.holzheuer
    christoph.holzheuer@gmail.com

    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.

***************************************************************************/


#include <QMessageBox>
#include <QUndoStack>

#include <xqexception.h>
#include <xqviewmodel.h>
#include <xqselectionmodel.h>
#include <xqtreetable.h>
#include <xqcommand.h>
#include <xqitemdelegate.h>
#include <xqitemfactory.h>
#include <znode_factory.h>


// create global dummy item as
// fallback return value (klappt nicht)
//Q_GLOBAL_STATIC(XQItem,s_dummyItem)


//! hilfsfunkion, zeigt den string-content() für alle elemente der liste

void showItemList( const XQItemList& list)
{
  for(const auto& entry : list )
    qDebug() << " --- itemList: " << entry->text();
  qDebug();
}

void showSelectionList( const QModelIndexList& list)
{
  for(const auto& entry : list )
    qDebug() << " --- SelectionList: " << entry.data().toString();
  qDebug();
}


//! Konstruktor mit parent.

XQViewModel::XQViewModel( QObject* parent )
  : QStandardItemModel{ parent }, _itemFactory{ XQItemFactory::instance() }
{
  invisibleRootItem()->setData( "[rootItem]", Qt::DisplayRole );
  setItemPrototype( new XQItem );

  // auf änderungen kann in den unterklassen reagiert werden
  connect(this, &QStandardItemModel::itemChanged, this, [this](QStandardItem *item)
  {
    XQItem* xqItem = static_cast<XQItem*>(item);
    emit xqItemChanged( *xqItem );
  });
  // not needed
  //qRegisterMetaType<XQItem>("XQItem");
}


//! gibt einen static-cast<QXItem*> auf 'invisibleRootItem()' zurück

const XQItem& XQViewModel::xqRootItem()
{
  // das ist ein hack, denn 'invisibleRootItem()' ist und bleibt ein
  // QStandardItem. Trick: keine eigenen members in XQItem, alles
  // dynamisch über den ItemData Mechanismus wie in QStandardItem

  return *static_cast<XQItem*>(invisibleRootItem());
}


//! Gibt den daten root node des models zurück.

XQNodePtr XQViewModel::contentRootNode()
{
  return _contentRoot;
}


//! hifsfunktion, die das item zu einen index zurückgibt

XQItem& XQViewModel::xqItemFromIndex(const QModelIndex& index) const
{
  if( index.isValid() )
  {
    QStandardItem* xqItem = QStandardItemModel::itemFromIndex(index);
    if( xqItem )
      return *static_cast<XQItem*>(xqItem);
  }
  return XQItem::fallBackDummyItem();
}

//! hilfsfunktiom, die das erste xqitem einer zeile zurückgibt.

XQItem& XQViewModel::xqFirstItem(int row) const
{
  return *static_cast<XQItem*>( QStandardItemModel::item(row) );
}

void XQViewModel::expandNewItem(const QModelIndex& index)
{
  if( _treeTable )
  {
    // ... ausklappen...
    _treeTable->expand( index );
    // ... und markieren
    _treeTable->setCurrentIndex( index );
  }
}

//! initialisiert dieses model über den namen. Es wird hier
//! nur die strukur erzeugt, keine inhalte.

void XQViewModel::initModel(const QString& modelName)
{
  /*
    model
      section
        header
        data
      section
        ...

   */
  setObjectName( modelName );
   // model rootnode finden -> <DocumentTreeModel>
  XQNodePtr modelSheet = _itemFactory.findModelSheet( modelName ); // throws

  // #1: über alle sections
  for( auto& sectionNode : modelSheet->children() )
  {
    // #2: (optionalen?) header erzeugen
    const XQNodePtr header = sectionNode->child( c_Header );
    if( header )
    {
      XQItemList list = _itemFactory.makeRow( header, nullptr );
      addSection(list,  sectionNode );
    }
  }
}


//! Hilfsfunktion: fügt die item-liste unserem model hinzu und erzeugt eine 'section'.
//! die section kann erst gültig sein, wenn die items im model gelandet sind,
//! deswegen ist das hier zusammengefasst.

//! Erzeugt dann eine section aus einer frisch erzeugten itemlist. Der erste modelindex
//! der liste und der root knoten der model-beschreibung werden gespeichert.

void XQViewModel::addSection(const XQItemList& list, const XQNodePtr& sheetNode )
{
  // 1. die liste darf nicht leer sein
  Q_ASSERT(!list.isEmpty());
  // 2. sheetNode muss da sein
  Q_ASSERT(sheetNode);
  // 3. 'ContenType' muss vorhanden sein
  if( !sheetNode->has_attribute( c_ContentType) )
    throw XQException( "section list: Section node needs attribute 'ContentType'!");

  // 4. das erzeugt dann auch valide indices
  appendRow(list);

  // 5. jetzt können wir auch die section erzeugen
  const XQModelSection& section = _sections.createSection( list[0]->index(), sheetNode );

  // ... und es der welt mitteilen.
  emit sectionCreated( section );

}


//! SLOT, toggled die section mit dem 'sectionKey' (hier: contentType)

void XQViewModel::onToggleSection(const QString& sectionKey )
{
  if(_sections.hasValidSection( sectionKey ) )
    toggleSection( _sections.sectionByKey(sectionKey) );
}


//! toggled die gegebene model section.

void XQViewModel::toggleSection( const XQModelSection& section )
{
  if( section.isValid() && _treeTable )
  {    
    XQSectionRange pos = _sections.sectionRange(section);
    qDebug() << " --- Section RANGE: " << pos.firstRow << " -> " << pos.lastRow;

    _treeTable->toggleRowsHidden(pos.firstRow, pos.lastRow );   
  }
}


/*
//! SLOT als weiterleitung vom SIGNAL itemchanged

void XQViewModel::onItemChanged(XQItem* item )
{
   qDebug() << " --- BASE item changed: " << item->text();

}
*/

//! SLOT, der aufgerufen wird, wenn eine edit-action getriggert wurde.

void XQViewModel::onActionTriggered(QAction* action)
{
  qDebug() << " --- onActionTriggered: count:" << action->text() <<": " << XQNode::s_Count;

  // all selected indices
  QModelIndexList selectionList = treeTable()->selectionModel()->selectedRows();
  // extract command type
  XQCommand::CmdType cmdType = action->data().value<XQCommand::CmdType>();

  switch( cmdType )
  {

    // just handle undo ...
    case XQCommand::cmdUndo :
      return _undoStack->undo();

    // ... or do/redo
    case XQCommand::cmdRedo :
      return _undoStack->redo();

    // for copy & cut, we create a clone of the dataNodes in the clipboard
    case XQCommand::cmdCopy :
    case XQCommand::cmdCut :
      // don't 'copy' empty selections
      if( !selectionList.isEmpty() )
        _clipBoard.saveNodes( selectionList );
      // for copy, we are done, since copy cannot be undone
      if(  cmdType == XQCommand::cmdCopy )
        return;

    default:
      break;
  }

  // we create a command
  XQCommand* command = new XQCommand( cmdType, this );
  QModelIndex currentIndex = treeTable()->currentIndex();
  command->setOriginIndex(currentIndex);
  // store the row positions of the selected indices
  showSelectionList(selectionList);
  command->saveNodes( selectionList );


  // execute command
  _undoStack->push( command );

}


//! führt die 'redo' action des gegebenen commnds aus.

void XQViewModel::onCommandRedo( const XQCommand& command )
{
  static MemCallMap redoCalls
  {
    { XQCommand::cmdToggleSection, &XQViewModel::cmdToggleSection },
    { XQCommand::cmdCut,           &XQViewModel::cmdCut },
    { XQCommand::cmdPaste,         &XQViewModel::cmdPaste },
    { XQCommand::cmdNew,           &XQViewModel::cmdNew },
    { XQCommand::cmdDelete,        &XQViewModel::cmdDelete }
  };

  try
  {
    MemCall memCall = redoCalls[command.commandType()];
    if( memCall )
      (this->*memCall)( command );
    else
      qDebug() << " --- onCommandRedo: default: not handled: " << command.toString();
  }
  catch( XQException& exception )
  {
    qDebug() << exception.what();
    QMessageBox::critical( nullptr, "Failure", QString("Failure: %1").arg(exception.what()) );
  }
}


//! führt die 'undo' action des gegebenen commnds aus.

void XQViewModel::onCommandUndo( const XQCommand& command )
{
  qDebug() << " --- onCommandUndo: count: " << XQNode::s_Count;

  static MemCallMap undoCalls
  {
    { XQCommand::cmdToggleSection, &XQViewModel::cmdToggleSection },
    { XQCommand::cmdCut,           &XQViewModel::cmdCutUndo },
    { XQCommand::cmdPaste,         &XQViewModel::cmdPasteUndo },
    { XQCommand::cmdNew,           &XQViewModel::cmdNewUndo },
    { XQCommand::cmdDelete,        &XQViewModel::cmdDeleteUndo },
  };

  try
  {
    MemCall memCall = undoCalls[command.commandType()];
    if( memCall )
      (this->*memCall)( command );
    else
      qDebug() << " --- onCommandUndo: default: not handled: " << command.toString();
  }
  catch( XQException& exception )
  {
    qDebug() << exception.what();
    QMessageBox::critical( nullptr, "Failure", QString("Failure: %1").arg(exception.what()) );
  }
}

// undo-/redo-able stuff

//! markierte knoten entfernen, 'command' enthält die liste

void XQViewModel::cmdCut( const XQCommand& command )
{
  // wir gehen rückwärts über alle gemerkten knoten ...
  for (auto it = command.rbegin(); it != command.rend(); ++it)
  {
   // ... holen das erste item, das auch den content node enthält
    // jetzt löschen, dabei wird die parent-verbindung entfernt
    const XQNodeBackup& entry = *it;
    entry.contentNode->unlink_self();
    removeRow(entry.itemPos );
  }
}


//! entfernte knoten wieder einfügen , 'command' enthält die liste

void XQViewModel::cmdCutUndo( const XQCommand& command )
{
  // die anfangsposition
  int itmPos  = command.first().itemPos;
  // die 'zuständige' section rausfinden
  const XQModelSection& section = _sections.sectionByRow( itmPos );

  // über alle einträge ...
  for (auto& entry : command )
  {
    const XQNodePtr& savedNode = entry.contentNode;
    // __fix! should not be _contentRoot!
    savedNode->add_me_at( entry.nodePos, _contentRoot );
    XQItemList list = _itemFactory.makeRow( section.sheetRootNode(), savedNode );
    insertRow( entry.itemPos, list );
  }
}


//! clipboard inhalte einfügen

void XQViewModel::cmdPaste( const XQCommand& command )
{  
  // selection holen ...
  QItemSelectionModel* selectionModel = treeTable()->selectionModel();
  // ... und löschen
  selectionModel->clearSelection();

  // aktuelles item finden
  const XQItem& item = xqItemFromIndex( command.originIndex() );

  // die neue item position ist unter dem akutellen item
  int insRow  = item.row()+1;
  int nodePos = item.contentNode()->own_pos()+1;

  // die zugehörige section finden
  const XQModelSection& section = _sections.sectionByRow( insRow-1 );
  // wir pasten das clipboard
  for (auto& entry : _clipBoard )
  {
    // noch einen clone vom clone im clipboard erzeugen ...
    XQNodePtr newNode = entry.contentNode->clone(section.contentRootNode() );
    // ... diesen einfügen ...
    newNode->add_me_at( nodePos );
    // ... und damit eine frische item-row erzeugen
    XQItemList list = _itemFactory.makeRow( section.sheetRootNode(), newNode );
    insertRow( insRow, list );
    // die neue item-row selektieren
    const QModelIndex& selIdx = list[0]->index();
    _treeTable->selectionModel()->select(selIdx, QItemSelectionModel::Select | QItemSelectionModel::Rows);
    // zur nächsten zeile
    insRow++;
    nodePos++;
  }

  // unsere änderungen merken fürs 'undo'
  const_cast<XQCommand&>(command).saveNodes( selectionModel->selectedRows() );

}


//! einfügen aus dem clipboard wieder rückgängig machen

void XQViewModel::cmdPasteUndo( const XQCommand& command )
{
  // wir gehen rückwärts über alle markieren knoten ...
  for (auto it = command.rbegin(); it != command.rend(); ++it)
  {
    // ... holen das erste item, das auch den content node enthält
    const XQNodeBackup& entry = *it;
    // jetzt löschen
    entry.contentNode->unlink_self();
    removeRow(entry.itemPos );
  }
}


// don't clone into clipboard, remove items

//! entfernen der selection ohne copy in clipboard.

void XQViewModel::cmdDelete( const XQCommand& command )
{
  // wir gehen rückwärts über alle markieren knoten ...
  for (auto it = command.rbegin(); it != command.rend(); ++it)
  {
    // ... holen das erste item, das auch den content node enthält
    const XQNodeBackup& entry = *it;
    // jetzt löschen
    entry.contentNode->unlink_self();
    removeRow(entry.itemPos );
  }
}

//! macht 'delete' wieder rückgängig.

void XQViewModel::cmdDeleteUndo( const XQCommand& command )
{
  cmdCutUndo(command);
}


//! legt eine neue, leere zeile an.

void XQViewModel::cmdNew( const XQCommand& command )
{
  const QModelIndex& origin = command.originIndex();

  XQItem& target = xqItemFromIndex( origin );
  // current data node
  XQNodePtr node = target.contentNode();
 // we create a new data node
  XQNodePtr newNode = XQNode::make_node( node->tag_name(), node->tag_value() );
  // store node in node->parent()
  newNode->add_me_at( node->own_pos(), node->parent() );
  //...
  const XQModelSection& section = _sections.sectionByRow( origin.row() );

  // neue, leere zeile erzeugen ...
  XQItemList list =_itemFactory.makeRow( section.sheetRootNode(), newNode );
  // ... zur treeview hinzufügen ...
  insertRow( origin.row(), list );
  // ... editierbar machen ...
  QModelIndex newIndex = list[0]->index();
  treeTable()->setCurrentIndex( newIndex );
  treeTable()->edit( newIndex );
  // ,,, und fürs undo speichern
  const_cast<XQCommand&>(command).saveNodes( {newIndex} );

}


//! entfernt die neu angelegte zeile.

void XQViewModel::cmdNewUndo( const XQCommand& command )
{
  cmdDelete( command );
}


//! schaltet eine section sichtbar oder unsichtbar.

void XQViewModel::cmdToggleSection( const XQCommand& command )
{
  const QModelIndex& index = command.originIndex();
  Q_ASSERT(index.isValid());
  const XQModelSection& section = _sections.sectionByRow(index.row());

  // Obacht! Das ist hier etwas unsauber, 'toogleSection'' ändert den check-State
  // im document-tree, was wiederum die 'toggleSection' auslöst, das gibt also
  // einen doppelten Aufruf und wir sind dann wieder im Anfangszustand.

  //toggleSection( section );
  emit sectionToggled(section);

}


//! gibt die treetable zurück

XQTreeTable* XQViewModel::treeTable()
{
  return _treeTable;
}

//! setzt die treetable als member.

void XQViewModel::setTreeTable(XQTreeTable* mainView )
{
  // store view for direct access: the maintree
  _treeTable = mainView;
  // set myself as model to the mainview
  _treeTable->setModel(this);
  XQItemDelegate* delegate = new XQItemDelegate( *this );
  _treeTable->setItemDelegate( delegate );

  _contextMenu = new XQContextMenu( mainView );

  connect( _treeTable, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(onShowContextMenu(QPoint)));
  //connect( _treeTable, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(onDoubleClicked(QModelIndex)) );
  connect(_contextMenu, SIGNAL(triggered(QAction*)), this, SLOT(onActionTriggered(QAction*)));

  // __fixme, die view soll über das modelsheet konfiguriert werden!
  setupViewProperties();
}


//! setzt die eigenschaften der TreeTable.

void XQViewModel::setupViewProperties()
{
  _treeTable->setContextMenuPolicy(Qt::CustomContextMenu);
  _treeTable->setEditTriggers(QAbstractItemView::DoubleClicked | QAbstractItemView::EditKeyPressed);
  _treeTable->setSelectionBehavior(QAbstractItemView::SelectRows);
  _treeTable->setSelectionMode(QAbstractItemView::ExtendedSelection);
  //_treeTable->setSelectionMode(QAbstractItemView::ContiguousSelection);
  _treeTable->setSelectionModel( new XQSelectionModel(this) );
}


//! gibt den undo-stack zurück.

QUndoStack* XQViewModel::undoStack()
{
  return _undoStack;
}


//! setzt den undo-stack.

void XQViewModel::setUndoStack( QUndoStack* undoStack )
{
  _undoStack = undoStack;
}


//! SLOT, der die erstellung & anzeige es context-menues triggert.

void XQViewModel::onShowContextMenu(const QPoint& point)
{
  initContextMenu();
  _contextMenu->popup(_treeTable->mapToGlobal(point));
}


//! gibt die namen der neuen data-roles zurück.
//! __fix: die alten roles fehlen hier!

QHash<int, QByteArray> XQViewModel::roleNames() const
{

  QHash<int, QByteArray> roles = QStandardItemModel::roleNames();
  roles[XQItem::ContentRole] = "content";
  roles[XQItem::ItemTypeRole] = "itemType";
  roles[XQItem::RenderStyleRole] = "renderStyle";
  roles[XQItem::EditorTypeRole] = "editorType";
  roles[XQItem::UnitTypeRole] = "unitType";
  roles[XQItem::FixedChoicesRole] = "fixedChoices";
  roles[XQItem::ContentNodeRole] = "contentNode";
  roles[XQItem::SheetNodeRole] = "sheetNode";
  roles[XQItem::TypeKeyRole] = "typeKey";

  return roles;

}

