// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8; -*-
/* This file is part of the KDE project
   Copyright (C) 2004  Esben Mose Hansen <kde@mosehansen.dk>
   Copyright (C) by Andrew Stanley-Jones
   Copyright (C) 2000 by Carsten Pfeiffer <pfeiffer@kde.org>

   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.

   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; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/
#include <kdebug.h>

#include "history.h"
#include "historystringitem.h"
#include "klipperpopup.h"

History::History( QObject* parent )
    : QObject( parent ),
      m_top(0L),
      m_popup( new KlipperPopup( this ) ),
      m_topIsUserSelected( false ),
      m_nextCycle(0L)
{
    connect( this, SIGNAL( changed() ), m_popup, SLOT( slotHistoryChanged() ) );

}


History::~History() {
    qDeleteAll(m_items);
}

void History::insert( HistoryItem* item ) {
    if ( !item )
        return;

    m_topIsUserSelected = false;
    items_t::iterator it = m_items.find(item->uuid());
    if (it != m_items.end()) {
        if (*it == m_top) {
            return;
        }
        slotMoveToTop( item->uuid() );
    } else {
        forceInsert( item );
    }

    emit topChanged();

}

void History::forceInsert( HistoryItem* item ) {
    if ( !item )
        return;
    if (m_items.find(item->uuid()) != m_items.end()) {
        return; // Don't insert duplicates
    }
    m_nextCycle = m_top;
    item->insertBetweeen(m_top ? m_items[m_top->previous_uuid()] : 0L, m_top);
    m_items.insert( item->uuid(), item );
    m_top = item;
    emit changed();
    trim();
}

void History::trim() {
    int i = m_items.count() - maxSize();
    if ( i <= 0 || !m_top )
        return;

    items_t::iterator bottom = m_items.find(m_top->previous_uuid());
    while ( i-- ) {
        items_t::iterator it = bottom;
        bottom = m_items.find((*bottom)->previous_uuid());
        m_items.erase(it);
    }
    (*bottom)->chain(m_top);
    if (m_items.size()<=1) {
        m_nextCycle = 0L;
    }
    emit changed();
}

void History::remove( const HistoryItem* newItem ) {
    if ( !newItem )
        return;

    items_t::iterator it = m_items.find(newItem->uuid());
    if (it == m_items.end()) {
        return;
    }

    if (*it == m_top) {
        m_top = m_items[m_top->next_uuid()];
    }
    m_items[(*it)->previous_uuid()]->chain(m_items[(*it)->next_uuid()]);
    m_items.erase(it);
}


void History::slotClear() {
    m_items.clear();
    m_top = 0L;
    emit changed();
}

void History::slotMoveToTop(QAction *action) {
    QByteArray uuid = action->data().toByteArray();
    if (uuid.isNull()) // not an action from popupproxy
        return;

    slotMoveToTop(uuid);
}

void History::slotMoveToTop(const QByteArray& uuid) {

    items_t::iterator it = m_items.find(uuid);
    if (it == m_items.end()) {
        return;
    }
    if (*it == m_top) {
        emit topChanged();
        return;
    }
    m_topIsUserSelected = true;

    m_nextCycle = m_top;
    m_items[(*it)->previous_uuid()]->chain(m_items[(*it)->next_uuid()]);
    (*it)->insertBetweeen(m_items[m_top->previous_uuid()], m_top);
    m_top = *it;
    emit changed();
    emit topChanged();
}

void History::setMaxSize( unsigned max_size ) {
    m_max_size = max_size;
    trim();

}

KlipperPopup* History::popup() {
    return m_popup;
}

void History::cycleNext() {
    if (m_top && m_nextCycle && m_nextCycle != m_top) {
        HistoryItem* prev = m_items[m_nextCycle->previous_uuid()];
        HistoryItem* next = m_items[m_nextCycle->next_uuid()];
        HistoryItem* endofhist = m_items[m_top->previous_uuid()];
        HistoryItem* aftertop = m_items[m_top->next_uuid()];
        if (prev == m_top) {
            prev = m_nextCycle;
            aftertop = m_top;
        }
        m_top->insertBetweeen(prev, next);
        m_nextCycle->insertBetweeen(endofhist, aftertop);
        m_top = m_nextCycle;
        m_nextCycle = next;
        emit changed();
    }
}

void History::cyclePrev() {
    if (m_top && m_nextCycle) {
        HistoryItem* prev = m_items[m_nextCycle->previous_uuid()];
        if (prev == m_top) {
            return;
        }
        HistoryItem* prevprev = m_items[prev->previous_uuid()];
        HistoryItem* endofhist = m_items[m_top->previous_uuid()];
        HistoryItem* aftertop = m_items[m_top->next_uuid()];
        if (prevprev == m_top) {
            prevprev = prev;
            aftertop = m_top;
        }
        m_top->insertBetweeen(prevprev,m_nextCycle);
        prev->insertBetweeen(endofhist, aftertop);
        m_nextCycle = m_top;
        m_top = prev;
        emit changed();
    }
}


const HistoryItem* History::nextInCycle() const
{
    return m_nextCycle != m_top ? m_nextCycle : 0L; // pointing to top=no more items

}

const HistoryItem* History::prevInCycle() const
{
    if (m_nextCycle) {
        const HistoryItem* prev = m_items[m_nextCycle->previous_uuid()];
        if (prev != m_top) {
            return prev;
        }
    }
    return 0L;

}

const HistoryItem* History::find(const QByteArray& uuid) const
{
    items_t::const_iterator it = m_items.find(uuid);
    return (it == m_items.end()) ? 0L : *it;
}

#include "history.moc"
