/***********************************************************************
* flistview.h - Widget FListView and FListViewItem                     *
*                                                                      *
* This file is part of the FINAL CUT widget toolkit                    *
*                                                                      *
* Copyright 2017-2020 Markus Gans                                      *
*                                                                      *
* FINAL CUT is free software; you can redistribute it and/or modify    *
* it under the terms of the GNU Lesser General Public License as       *
* published by the Free Software Foundation; either version 3 of       *
* the License, or (at your option) any later version.                  *
*                                                                      *
* FINAL CUT 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 Lesser General Public License for more details.                  *
*                                                                      *
* You should have received a copy of the GNU Lesser General Public     *
* License along with this program.  If not, see                        *
* <http://www.gnu.org/licenses/>.                                      *
***********************************************************************/

/*  Inheritance diagram
 *  ═══════════════════
 *
 * ▕▔▔▔▔▔▔▔▔▔▏ ▕▔▔▔▔▔▔▔▔▔▏
 * ▕ FVTerm  ▏ ▕ FObject ▏
 * ▕▁▁▁▁▁▁▁▁▁▏ ▕▁▁▁▁▁▁▁▁▁▏
 *      ▲           ▲
 *      │           │
 *      └─────┬─────┘
 *            │
 *       ▕▔▔▔▔▔▔▔▔▔▏           ▕▔▔▔▔▔▔▔▔▔▏
 *       ▕ FWidget ▏           ▕ FObject ▏
 *       ▕▁▁▁▁▁▁▁▁▁▏           ▕▁▁▁▁▁▁▁▁▁▏
 *            ▲                     ▲
 *            │                     │
 *      ▕▔▔▔▔▔▔▔▔▔▔▔▏1     *▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏1     1▕▔▔▔▔▔▔▔▏
 *      ▕ FListView ▏- - - -▕ FListViewItem ▏- - - -▕ FData ▏
 *      ▕▁▁▁▁▁▁▁▁▁▁▁▏       ▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏       ▕▁▁▁▁▁▁▁▏
 */

#ifndef FLISTVIEW_H
#define FLISTVIEW_H

#if !defined (USE_FINAL_H) && !defined (COMPILE_FINAL_CUT)
  #error "Only <final/final.h> can be included directly."
#endif

#include <list>
#include <memory>
#include <stack>
#include <unordered_map>
#include <vector>

#include "final/fdata.h"
#include "final/fscrollbar.h"
#include "final/ftermbuffer.h"
#include "final/ftypes.h"
#include "final/fwidget.h"

namespace finalcut
{

// class forward declaration
class FListView;
class FScrollbar;
class FString;

//----------------------------------------------------------------------
// class FListViewItem
//----------------------------------------------------------------------

class FListViewItem : public FObject
{
  public:
    // Constructor
    FListViewItem (const FListViewItem&);  // copy constructor
    explicit FListViewItem (iterator);
    template <typename DT>
    FListViewItem (const FStringList&, DT&&, iterator);

    // Destructor
    ~FListViewItem() override;

    // copy assignment operator (=)
    FListViewItem& operator = (const FListViewItem&);

    // Accessors
    FString             getClassName() const override;
    uInt                getColumnCount() const;
    int                 getSortColumn() const;
    FString             getText (int) const;
    template <typename DT>
    clean_fdata_t<DT>&  getData() const;
    uInt                getDepth() const;

    // Mutators
    void                setText (int, const FString&);
    template <typename DT>
    void                setData (DT&&);
    void                setCheckable (bool);
    void                setChecked (bool);

    // Inquiry
    bool                isChecked() const;
    bool                isExpand() const;

    // Methods
    iterator            insert (FListViewItem*);
    iterator            insert (FListViewItem*, iterator) const;
    void                remove (FListViewItem*) const;
    void                expand();
    void                collapse();

  private:
    // Using-declaration
    using FDataAccessPtr = std::shared_ptr<FDataAccess>;

    // Inquiry
    bool                isExpandable() const;
    bool                isCheckable() const;

    // Methods
    template <typename Compare>
    void                sort (Compare);
    iterator            appendItem (FListViewItem*);
    void                replaceControlCodes();
    std::size_t         getVisibleLines();
    void                resetVisibleLineCounter();

    // Data members
    FStringList         column_list{};
    FDataAccessPtr      data_pointer{};
    iterator            root{};
    std::size_t         visible_lines{1};
    bool                expandable{false};
    bool                is_expand{false};
    bool                checkable{false};
    bool                is_checked{false};

    // Friend class
    friend class FListView;
    friend class FListViewIterator;
};


// FListViewItem inline functions
//----------------------------------------------------------------------
template <typename DT>
inline FListViewItem::FListViewItem ( const FStringList& cols
                                    , DT&& data
                                    , iterator parent_iter )
  : FObject{nullptr}
  , column_list{cols}
  , data_pointer{makeFData(std::forward<DT>(data))}
{
  if ( cols.empty() )
    return;

  replaceControlCodes();
  insert (this, parent_iter);
}

//----------------------------------------------------------------------
inline FString FListViewItem::getClassName() const
{ return "FListViewItem"; }

//----------------------------------------------------------------------
inline uInt FListViewItem::getColumnCount() const
{ return uInt(column_list.size()); }

//----------------------------------------------------------------------
template <typename DT>
inline clean_fdata_t<DT>& FListViewItem::getData() const
{
  return static_cast<FData<clean_fdata_t<DT>>&>(*data_pointer).get();
}

//----------------------------------------------------------------------
template <typename DT>
inline void FListViewItem::setData (DT&& data)
{
  const auto data_obj = makeFData(std::forward<DT>(data));
  data_pointer = data_obj;
}

//----------------------------------------------------------------------
inline void FListViewItem::setChecked (bool checked)
{ is_checked = checked; }

//----------------------------------------------------------------------
inline bool FListViewItem::isChecked() const
{ return is_checked; }

//----------------------------------------------------------------------
inline bool FListViewItem::isExpand() const
{ return is_expand; }

//----------------------------------------------------------------------
inline bool FListViewItem::isExpandable() const
{ return expandable; }

//----------------------------------------------------------------------
inline bool FListViewItem::isCheckable() const
{ return checkable; }


//----------------------------------------------------------------------
// class FListViewIterator
//----------------------------------------------------------------------

class FListViewIterator
{
  public:
    // Using-declarations
    using FObjectList    = std::list<FObject*>;
    using iterator       = FObjectList::iterator;
    using iterator_stack = std::stack<iterator>;

    // Constructor
    FListViewIterator () = default;
    FListViewIterator (iterator);
    FListViewIterator (const FListViewIterator&) = default;
    FListViewIterator (FListViewIterator&& )
        noexcept (std::is_nothrow_move_constructible<FListViewIterator>::value)
        = default;
    // Overloaded operators
    FListViewIterator& operator = (const FListViewIterator&) = default;
    FListViewIterator& operator = (FListViewIterator&&) noexcept = default;
    FListViewIterator& operator ++ ();     // prefix
    FListViewIterator  operator ++ (int);  // postfix
    FListViewIterator& operator -- ();     // prefix
    FListViewIterator  operator -- (int);  // postfix
    FListViewIterator& operator += (int);
    FListViewIterator& operator -= (int);
    FObject*&          operator * () const;
    FObject*           operator -> () const;
    bool               operator == (const FListViewIterator&) const;
    bool               operator != (const FListViewIterator&) const;

    // Accessor
    FString            getClassName() const;
    int&               getPosition();

    // Methods
    void               parentElement();

  private:
    // Methods
    void               nextElement (iterator&);
    void               prevElement (iterator&);

    // Data members
    iterator_stack     iter_path{};
    iterator           node{};
    int                position{0};
};


// FListViewIterator inline functions
//----------------------------------------------------------------------
inline FObject*& FListViewIterator::operator * () const
{ return *node; }

//----------------------------------------------------------------------
inline FObject* FListViewIterator::operator -> () const
{ return *node; }

//----------------------------------------------------------------------
inline bool FListViewIterator::operator == (const FListViewIterator& rhs) const
{ return node == rhs.node; }

//----------------------------------------------------------------------
inline bool FListViewIterator::operator != (const FListViewIterator& rhs) const
{ return node != rhs.node; }

//----------------------------------------------------------------------
inline FString FListViewIterator::getClassName() const
{ return "FListViewIterator"; }

//----------------------------------------------------------------------
inline int& FListViewIterator::getPosition()
{ return position; }


//----------------------------------------------------------------------
// class FListView
//----------------------------------------------------------------------

class FListView : public FWidget
{
  public:
    // Using-declaration
    using FWidget::setGeometry;

    // Typedef
    typedef std::list<FListViewItem*>  FListViewItems;

    // Constructor
    explicit FListView (FWidget* = nullptr);

    // Disable copy constructor
    FListView (const FListView&) = delete;

    // Destructor
    ~FListView() override;

    // Disable copy assignment operator (=)
    FListView& operator = (const FListView&) = delete;

    // Accessors
    FString               getClassName() const override;
    std::size_t           getCount() const;
    fc::text_alignment    getColumnAlignment (int) const;
    FString               getColumnText (int) const;
    fc::sorting_type      getColumnSortType (int) const;
    fc::sorting_order     getSortOrder() const;
    int                   getSortColumn() const;
    FListViewItem*        getCurrentItem();

    // Mutators
    void                  setSize (const FSize&, bool = true) override;
    void                  setGeometry ( const FPoint&, const FSize&
                                      , bool = true ) override;
    void                  setColumnAlignment (int, fc::text_alignment);
    void                  setColumnText (int, const FString&);
    void                  setColumnSortType (int, fc::sorting_type \
                                                      = fc::by_name);
    void                  setColumnSort (int, fc::sorting_order \
                                                  = fc::ascending);
    template <typename Compare>
    void                  setUserAscendingCompare (Compare);
    template <typename Compare>
    void                  setUserDescendingCompare (Compare);
    void                  hideSortIndicator (bool);
    bool                  setTreeView (bool);
    bool                  setTreeView();
    bool                  unsetTreeView();

    // Methods
    virtual int           addColumn (const FString&, int = USE_MAX_SIZE);
    void                  hide() override;
    iterator              insert (FListViewItem*);
    iterator              insert (FListViewItem*, iterator);
    template <typename DT = std::nullptr_t>
    iterator              insert ( const FStringList&
                                 , DT&& = DT() );
    iterator              insert ( const FStringList&
                                 , iterator );
    template <typename DT>
    iterator              insert ( const FStringList&
                                 , DT&&
                                 , iterator );
    template <typename T
            , typename DT = std::nullptr_t>
    iterator              insert ( const std::initializer_list<T>&
                                 , DT&& = DT() );
    template <typename T>
    iterator              insert ( const std::initializer_list<T>&
                                 , iterator );
    template <typename T
            , typename DT>
    iterator              insert ( const std::initializer_list<T>&
                                 , DT&&
                                 , iterator );
    template <typename ColT
            , typename DT = std::nullptr_t>
    iterator              insert ( const std::vector<ColT>&
                                 , DT&& = DT() );
    template <typename ColT>
    iterator              insert ( const std::vector<ColT>&
                                 , iterator );
    template <typename ColT
            , typename DT>
    iterator              insert ( const std::vector<ColT>&
                                 , DT&&
                                 , iterator );
    void                  remove (FListViewItem*);
    void                  clear();
    FListViewItems&       getData();
    const FListViewItems& getData() const;

    virtual void          sort();

    // Event handlers
    void                  onKeyPress (FKeyEvent*) override;
    void                  onMouseDown (FMouseEvent*) override;
    void                  onMouseUp (FMouseEvent*) override;
    void                  onMouseMove (FMouseEvent*) override;
    void                  onMouseDoubleClick (FMouseEvent*) override;
    void                  onWheel (FWheelEvent*) override;
    void                  onTimer (FTimerEvent*) override;
    void                  onFocusIn (FFocusEvent*) override;
    void                  onFocusOut (FFocusEvent*) override;

  protected:
    // Methods
    void                  adjustViewport (const int);
    void                  adjustScrollbars (const std::size_t) const;
    void                  adjustSize() override;

  private:
    // Typedefs
    typedef std::unordered_map<int, std::function<void()>> KeyMap;
    typedef std::unordered_map<int, std::function<bool()>> KeyMapResult;

    // Constants
    static constexpr std::size_t checkbox_space = 4;

    // Typedef
    struct Header;  // forward declaration
    typedef std::vector<Header> HeaderItems;
    typedef std::vector<fc::sorting_type> SortTypes;

    // Constants
    static constexpr int USE_MAX_SIZE = -1;

    // Accessors
    static iterator&      getNullIterator();

    // Mutators
    static void           setNullIterator (const iterator&);

    // Inquiry
    bool                  isHorizontallyScrollable() const;
    bool                  isVerticallyScrollable() const;

    // Methods
    void                  init();
    void                  mapKeyFunctions();
    void                  processKeyAction (FKeyEvent*);
    template <typename Compare>
    void                  sort (Compare);
    std::size_t           getAlignOffset ( const fc::text_alignment
                                         , const std::size_t
                                         , const std::size_t ) const;
    iterator              getListEnd (const FListViewItem*);
    void                  draw() override;
    void                  drawBorder() override;
    void                  drawScrollbars() const;
    void                  drawHeadlines();
    void                  drawList();
    void                  drawListLine (const FListViewItem*, bool, bool);
    void                  clearList();
    void                  setLineAttributes (bool, bool) const;
    FString               getCheckBox (const FListViewItem* item) const;
    FString               getLinePrefix (const FListViewItem*, std::size_t) const;
    void                  drawSortIndicator (std::size_t&, std::size_t);
    void                  drawHeadlineLabel (const HeaderItems::const_iterator&);
    void                  drawHeaderBorder (std::size_t);
    void                  drawBufferedHeadline();
    void                  drawColumnEllipsis ( const HeaderItems::const_iterator&
                                             , const FString& );
    void                  updateDrawing (bool, bool);
    std::size_t           determineLineWidth (FListViewItem*);
    void                  beforeInsertion (FListViewItem*);
    void                  afterInsertion();
    void                  recalculateHorizontalBar (std::size_t);
    void                  recalculateVerticalBar (std::size_t) const;
    void                  mouseHeaderClicked();
    void                  wheelUp (int);
    void                  wheelDown (int);
    bool                  dragScrollUp (int);
    bool                  dragScrollDown (int);
    void                  dragUp (int);
    void                  dragDown (int);
    void                  stopDragScroll();
    iterator              appendItem (FListViewItem*);
    void                  processClick() const;
    void                  processChanged() const;
    void                  changeOnResize() const;
    void                  toggleCheckbox();
    void                  collapseAndScrollLeft();
    void                  expandAndScrollRight();
    void                  firstPos();
    void                  lastPos();
    bool                  expandSubtree();
    bool                  collapseSubtree();
    void                  setRelativePosition (int);
    void                  stepForward();
    void                  stepBackward();
    void                  stepForward (int);
    void                  stepBackward (int);
    void                  scrollToX (int);
    void                  scrollToY (int);
    void                  scrollTo (const FPoint &);
    void                  scrollTo (int, int);
    void                  scrollBy (int, int);
    bool                  hasCheckableItems() const;

    // Callback methods
    void                  cb_vbarChange (const FWidget*);
    void                  cb_hbarChange (const FWidget*);

    // Data members
    iterator              root{};
    FObjectList           selflist{};
    FObjectList           itemlist{};
    FListViewIterator     current_iter{};
    FListViewIterator     first_visible_line{};
    FListViewIterator     last_visible_line{};
    HeaderItems           header{};
    FTermBuffer           headerline{};
    FScrollbarPtr         vbar{nullptr};
    FScrollbarPtr         hbar{nullptr};
    SortTypes             sort_type{};
    FPoint                clicked_expander_pos{-1, -1};
    FPoint                clicked_header_pos{-1, -1};
    KeyMap                key_map{};
    KeyMapResult          key_map_result{};
    const FListViewItem*  clicked_checkbox_item{nullptr};
    std::size_t           nf_offset{0};
    std::size_t           max_line_width{1};
    fc::dragScroll        drag_scroll{fc::noScroll};
    int                   first_line_position_before{-1};
    int                   scroll_repeat{100};
    int                   scroll_distance{1};
    int                   xoffset{0};
    int                   sort_column{-1};
    fc::sorting_order     sort_order{fc::unsorted};
    bool                  scroll_timer{false};
    bool                  tree_view{false};
    bool                  hide_sort_indicator{false};
    bool                  has_checkable_items{false};

    // Function Pointer
    bool (*user_defined_ascending) (const FObject*, const FObject*){nullptr};
    bool (*user_defined_descending) (const FObject*, const FObject*){nullptr};

    // Friend class
    friend class FListViewItem;
};


//----------------------------------------------------------------------
// struct FListView::Header
//----------------------------------------------------------------------

struct FListView::Header
{
  public:
    Header () = default;

    FString name{};
    fc::text_alignment alignment{fc::alignLeft};
    int width{0};
    bool fixed_width{false};
};


// FListView inline functions
//----------------------------------------------------------------------
inline FString FListView::getClassName() const
{ return "FListView"; }

//----------------------------------------------------------------------
inline fc::sorting_order FListView::getSortOrder() const
{ return sort_order; }

//----------------------------------------------------------------------
inline int FListView::getSortColumn() const
{ return sort_column; }

//----------------------------------------------------------------------
inline FListViewItem* FListView::getCurrentItem()
{ return static_cast<FListViewItem*>(*current_iter); }

//----------------------------------------------------------------------
template <typename Compare>
inline void FListView::setUserAscendingCompare (Compare cmp)
{ user_defined_ascending = cmp; }

//----------------------------------------------------------------------
template <typename Compare>
inline void FListView::setUserDescendingCompare (Compare cmp)
{ user_defined_descending = cmp; }

//----------------------------------------------------------------------
inline void FListView::hideSortIndicator (bool hide)
{ hide_sort_indicator = hide; }

//----------------------------------------------------------------------
inline bool FListView::setTreeView (bool enable)
{ return (tree_view = enable); }

//----------------------------------------------------------------------
inline bool FListView::setTreeView()
{ return setTreeView(true); }

//----------------------------------------------------------------------
inline bool FListView::unsetTreeView()
{ return setTreeView(false); }

//----------------------------------------------------------------------
inline FObject::iterator FListView::insert (FListViewItem* item)
{ return insert (item, root); }

//----------------------------------------------------------------------
template <typename DT>
inline FObject::iterator
    FListView::insert (const FStringList& cols, DT&& d)
{ return insert (cols, std::forward<DT>(d), root); }

//----------------------------------------------------------------------
inline FObject::iterator
    FListView::insert ( const FStringList& cols
                      , iterator parent_iter )
{ return insert (cols, nullptr, parent_iter); }

//----------------------------------------------------------------------
template <typename DT>
inline FObject::iterator FListView::insert ( const FStringList& cols
                                           , DT&& d
                                           , iterator parent_iter )
{
  FListViewItem* item;

  if ( cols.empty() || parent_iter == getNullIterator() )
    return getNullIterator();

  if ( ! *parent_iter )
    parent_iter = root;

  try
  {
    item = new FListViewItem (cols, std::forward<DT>(d), getNullIterator());
  }
  catch (const std::bad_alloc&)
  {
    badAllocOutput ("FListViewItem");
    return getNullIterator();
  }

  item->replaceControlCodes();
  return insert(item, parent_iter);
}

//----------------------------------------------------------------------
template <typename T
        , typename DT>
inline FObject::iterator
    FListView::insert (const std::initializer_list<T>& list, DT&& d)
{ return insert (list, std::forward<DT>(d), root); }

//----------------------------------------------------------------------
template <typename T>
inline FObject::iterator
    FListView::insert ( const std::initializer_list<T>& list
                      , iterator parent_iter )
{ return insert (list, 0, parent_iter); }

//----------------------------------------------------------------------
template <typename T
        , typename DT>
FObject::iterator
    FListView::insert ( const std::initializer_list<T>& list
                      , DT&& d
                      , iterator parent_iter )
{
  FStringList str_cols;

  std::transform ( std::begin(list)
                 , std::end(list)
                 , std::back_inserter(str_cols)
                 , [] (const T& col)
                   {
                     const FString s(FString() << col);
                     return s;
                   }
                 );

  auto item_iter = insert (str_cols, std::forward<DT>(d), parent_iter);
  return item_iter;
}

//----------------------------------------------------------------------
template <typename ColT
        , typename DT>
inline FObject::iterator
    FListView::insert (const std::vector<ColT>& cols, DT&& d)
{ return insert (cols, std::forward<DT>(d), root); }

//----------------------------------------------------------------------
template <typename ColT>
inline FObject::iterator
    FListView::insert ( const std::vector<ColT>& cols
                      , iterator parent_iter )
{ return insert (cols, 0, parent_iter); }

//----------------------------------------------------------------------
template <typename ColT
        , typename DT>
FObject::iterator
    FListView::insert ( const std::vector<ColT>& cols
                      , DT&& d
                      , iterator parent_iter )
{
  FStringList str_cols;

  std::transform ( std::begin(cols)
                 , std::end(cols)
                 , std::back_inserter(str_cols)
                 , [] (const ColT& col)
                   {
                     const FString s(FString() << col);
                     return s;
                   }
                 );

  auto item_iter = insert (str_cols, std::forward<DT>(d), parent_iter);
  return item_iter;
}

//----------------------------------------------------------------------
inline FListView::FListViewItems& FListView::getData()
{ return reinterpret_cast<FListViewItems&>(itemlist); }

//----------------------------------------------------------------------
inline const FListView::FListViewItems& FListView::getData() const
{ return reinterpret_cast<const FListViewItems&>(itemlist); }

//----------------------------------------------------------------------
inline bool FListView::isHorizontallyScrollable() const
{ return bool( max_line_width > getClientWidth() ); }

//----------------------------------------------------------------------
inline bool FListView::isVerticallyScrollable() const
{ return bool( getCount() > getClientHeight() ); }

//----------------------------------------------------------------------
inline void FListView::scrollTo (const FPoint& pos)
{ scrollTo(pos.getX(), pos.getY()); }

//----------------------------------------------------------------------
inline bool FListView::hasCheckableItems() const
{ return has_checkable_items; }

}  // namespace finalcut

#endif  // FLISTVIEW_H