/* This file is part of the KDE project
    Copyright (C) 1997 Tim D. Gilman (tdgilman@best.org)
              (C) 1998-2001 Mirko Boehm (mirko@kde.org)
              (C) 2004 Dag Andersen <danders@get2net.dk>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

/* This is based on KDatePicker. */

#include "kptcalendarpanel.h"
#include "kptdatetable.h"
#include "kptcalendar.h"


#include <tdeglobal.h>
#include <tdeapplication.h>
#include <tdelocale.h>
#include <kcalendarsystem.h> 
#include <kiconloader.h>
#include <tqframe.h>
#include <tqpainter.h>
#include <tqdialog.h>
#include <tqstyle.h>
#include <tqtoolbutton.h>
#include <tqtooltip.h>
#include <tqfont.h>
#include <klineedit.h>
#include <tqvalidator.h>
#include <kdebug.h>
#include <knotifyclient.h>

namespace KPlato
{

class CalendarPanel::CalendarPanelPrivate
{
public:
    CalendarPanelPrivate() : closeButton(0L), selectWeek(0L) {}

    TQToolButton *closeButton;
    TQToolButton *selectWeek;
};


CalendarPanel::CalendarPanel(TQWidget *parent, TQDate dt, const char *name, WFlags f)
  : TQFrame(parent,name, f)
{
  init( dt );
}

CalendarPanel::CalendarPanel( TQWidget *parent, const char *name )
  : TQFrame(parent,name)
{
    init( TQDate::currentDate() );
}

void CalendarPanel::init( const TQDate &dt )
{
  yearForward = new TQToolButton(this);
  yearBackward = new TQToolButton(this);
  monthForward = new TQToolButton(this);
  monthBackward = new TQToolButton(this);
  selectMonth = new TQToolButton(this);
  selectYear = new TQToolButton(this);
  line = new KLineEdit(this);
  val = new DateValidator(this);
  table = new DateTable(this, dt, "Calendar table", 0);
  fontsize = 10;

  d = new CalendarPanelPrivate();
  d->selectWeek = new TQToolButton( this );

  TQToolTip::add(yearForward, i18n("Next year"));
  TQToolTip::add(yearBackward, i18n("Previous year"));
  TQToolTip::add(monthForward, i18n("Next month"));
  TQToolTip::add(monthBackward, i18n("Previous month"));
  TQToolTip::add(d->selectWeek, i18n("Select a week"));
  TQToolTip::add(selectMonth, i18n("Select a month"));
  TQToolTip::add(selectYear, i18n("Select a year"));

  // -----
  setFontSize(10);
  line->setValidator(val);
  line->installEventFilter( this );
  yearForward->setPixmap(BarIcon(TQString::fromLatin1("2rightarrow")));
  yearBackward->setPixmap(BarIcon(TQString::fromLatin1("2leftarrow")));
  monthForward->setPixmap(BarIcon(TQString::fromLatin1("1rightarrow")));
  monthBackward->setPixmap(BarIcon(TQString::fromLatin1("1leftarrow")));
  setDate(dt); // set button texts
  connect(table, TQT_SIGNAL(dateChanged(TQDate)), TQT_SLOT(dateChangedSlot(TQDate)));
  connect(table, TQT_SIGNAL(tableClicked()), TQT_SLOT(tableClickedSlot()));
  connect(monthForward, TQT_SIGNAL(clicked()), TQT_SLOT(monthForwardClicked()));
  connect(monthBackward, TQT_SIGNAL(clicked()), TQT_SLOT(monthBackwardClicked()));
  connect(yearForward, TQT_SIGNAL(clicked()), TQT_SLOT(yearForwardClicked()));
  connect(yearBackward, TQT_SIGNAL(clicked()), TQT_SLOT(yearBackwardClicked()));
  connect(d->selectWeek, TQT_SIGNAL(clicked()), TQT_SLOT(selectWeekClicked()));
  connect(selectMonth, TQT_SIGNAL(clicked()), TQT_SLOT(selectMonthClicked()));
  connect(selectYear, TQT_SIGNAL(clicked()), TQT_SLOT(selectYearClicked()));
  connect(line, TQT_SIGNAL(returnPressed()), TQT_SLOT(lineEnterPressed()));

  connect(table, TQT_SIGNAL(weekdaySelected(int)), TQT_SLOT(slotWeekdaySelected(int)));
  connect(table, TQT_SIGNAL(weekSelected(int, int)), TQT_SLOT(slotWeekSelected(int, int)));
  connect(table, TQT_SIGNAL(selectionCleared()), TQT_SLOT(slotSelectionCleared()));

  table->setFocus();
}

CalendarPanel::~CalendarPanel()
{
  delete d;
}

bool
CalendarPanel::eventFilter(TQObject *o, TQEvent *e )
{
   if ( e->type() == TQEvent::KeyPress ) {
      TQKeyEvent *k = (TQKeyEvent *)e;

      if ( (k->key() == TQt::Key_Prior) ||
           (k->key() == TQt::Key_Next)  ||
           (k->key() == TQt::Key_Up)    ||
           (k->key() == TQt::Key_Down) )
       {
          TQApplication::sendEvent( table, e );
          table->setFocus();
          return TRUE; // eat event
       }
   }
   return TQFrame::eventFilter( o, e );
}

void
CalendarPanel::resizeEvent(TQResizeEvent*)
{
    TQWidget *buttons[] = {
	yearBackward,
	    monthBackward,
	    selectMonth,
	    selectYear,
	    monthForward,
	    yearForward,
	    d->closeButton
    };
    const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
    TQSize sizes[NoOfButtons];
    int buttonHeight=0;
    int count;
    int w=0;
    int x=0;
    // ----- calculate button row height:
    for(count=0; count<NoOfButtons; ++count) {
        if ( buttons[count] ) { // closeButton may be 0L
            sizes[count]=buttons[count]->sizeHint();
            buttonHeight=TQMAX(buttonHeight, sizes[count].height());
        }
        else
            sizes[count] = TQSize(0,0); // closeButton
    }

    // ----- calculate size of the month button:
    for(count=0; count<NoOfButtons; ++count) {
        if(buttons[count]==selectMonth) {
            TQSize metricBound = style().tqsizeFromContents(TQStyle::CT_ToolButton, selectMonth, maxMonthRect);
            sizes[count].setWidth(TQMAX(metricBound.width(), maxMonthRect.width()+2*TQApplication::style().pixelMetric(TQStyle::PM_ButtonMargin)));
        }
    }
    // ----- center buttons
    w=0;
    for(count=0; count<NoOfButtons; ++count)
    {
        w +=sizes[count].width();
    }
    x = (TQMAX(w, width())-w)/2;

    // ----- place the buttons:
    for(count=0; count<NoOfButtons; ++count)
    {
        w=sizes[count].width();
        if ( buttons[count] )
            buttons[count]->setGeometry(x, 0, w, buttonHeight);
        x+=w;
    }
    // ----- place the line edit for direct input:
    sizes[0]=line->sizeHint();
    int week_width=d->selectWeek->fontMetrics().width(i18n("Week XX"))+((d->closeButton != 0L) ? 50 : 20);
    line->setGeometry(0, height()-sizes[0].height(), width()-week_width, sizes[0].height());
    d->selectWeek->setGeometry(width()-week_width, height()-sizes[0].height(), week_width, sizes[0].height());
    // ----- adjust the table:
    table->setGeometry(0, buttonHeight, width(),
		       height()-buttonHeight-sizes[0].height());
}

void
CalendarPanel::dateChangedSlot(TQDate date)
{
    //kdDebug() << "CalendarPanel::dateChangedSlot: date changed (" << date.year() << "/" << date.month() << "/" << date.day() << ")." << endl;
    line->setText(TDEGlobal::locale()->formatDate(date, true));
    d->selectWeek->setText(i18n("Week %1").arg(weekOfYear(date)));
    selectMonth->setText(TDEGlobal::locale()->calendar()->monthName(date.month(), false));
    selectYear->setText(date.toString("yyyy"));
    emit(dateChanged(date));
}

void
CalendarPanel::tableClickedSlot()
{
  //kdDebug() << "CalendarPanel::tableClickedSlot: table clicked." << endl;
  emit(dateSelected(table->getDate()));
  emit(tableClicked());
}

const TQDate&
CalendarPanel::getDate() const
{
  return table->getDate();
}

const TQDate &
CalendarPanel::date() const
{
    return table->getDate();
}

bool
CalendarPanel::setDate(const TQDate& date)
{
    if(date.isValid()) {
	TQString temp;
	// -----
	table->setDate(date);
	d->selectWeek->setText(i18n("Week %1").arg(weekOfYear(date)));
	selectMonth->setText(TDEGlobal::locale()->calendar()->monthName(date.month(), false));
	temp.setNum(date.year());
	selectYear->setText(temp);
	line->setText(TDEGlobal::locale()->formatDate(date, true));
	return true;
    } else {
	kdDebug() << "CalendarPanel::setDate: refusing to set invalid date." << endl;
	return false;
    }
}

void
CalendarPanel::monthForwardClicked()
{
    setDate( table->getDate().addMonths(1) );
}

void
CalendarPanel::monthBackwardClicked()
{
    setDate( table->getDate().addMonths(-1) );
}

void
CalendarPanel::yearForwardClicked()
{
    setDate( table->getDate().addYears(1) );
}

void
CalendarPanel::yearBackwardClicked()
{
    setDate( table->getDate().addYears(-1) );
}

void
CalendarPanel::selectWeekClicked()
{
  int week;
  PopupFrame* popup = new PopupFrame(this);
  DateInternalWeekSelector* picker = new DateInternalWeekSelector(fontsize, popup);
  // -----
  picker->resize(picker->sizeHint());
  popup->setMainWidget(picker);
  connect(picker, TQT_SIGNAL(closeMe(int)), popup, TQT_SLOT(close(int)));
  picker->setFocus();
  if(popup->exec(d->selectWeek->mapToGlobal(TQPoint(0, d->selectWeek->height()))))
    {
      TQDate date;
      int year;
      // -----
      week=picker->getWeek();
      date=table->getDate();
      year=date.year();
      // ----- find the first selectable day in this week (hacky solution :)
      date.setYMD(year, 1, 1);
      while (weekOfYear(date)>50)
          date=date.addDays(1);
      while (weekOfYear(date)<week && (week!=53 || (week==53 &&
            (weekOfYear(date)!=52 || weekOfYear(date.addDays(1))!=1))))
          date=date.addDays(1);
      if (week==53 && weekOfYear(date)==52)
          while (weekOfYear(date.addDays(-1))==52)
              date=date.addDays(-1);
      // ----- set this date
      setDate(date);
    } else {
         KNotifyClient::beep();
    }
  delete popup;
}

void
CalendarPanel::selectMonthClicked()
{
  int month;
  PopupFrame* popup = new PopupFrame(this);
  DateInternalMonthPicker* picker = new DateInternalMonthPicker(fontsize, popup);
  // -----
  picker->resize(picker->sizeHint());
  popup->setMainWidget(picker);
  picker->setFocus();
  connect(picker, TQT_SIGNAL(closeMe(int)), popup, TQT_SLOT(close(int)));
  if(popup->exec(selectMonth->mapToGlobal(TQPoint(0, selectMonth->height()))))
    {
      TQDate date;
      int day;
      // -----
      month=picker->getResult();
      date=table->getDate();
      day=date.day();
      // ----- construct a valid date in this month:
      date.setYMD(date.year(), month, 1);
      date.setYMD(date.year(), month, TQMIN(day, date.daysInMonth()));
      // ----- set this month
      setDate(date);
    } else {
      KNotifyClient::beep();
    }
  delete popup;
}

void
CalendarPanel::selectYearClicked()
{
  int year;
  PopupFrame* popup = new PopupFrame(this);
  DateInternalYearSelector* picker = new DateInternalYearSelector(fontsize, popup);
  // -----
  picker->resize(picker->sizeHint());
  popup->setMainWidget(picker);
  connect(picker, TQT_SIGNAL(closeMe(int)), popup, TQT_SLOT(close(int)));
  picker->setFocus();
  if(popup->exec(selectYear->mapToGlobal(TQPoint(0, selectMonth->height()))))
    {
      TQDate date;
      int day;
      // -----
      year=picker->getYear();
      date=table->getDate();
      day=date.day();
      // ----- construct a valid date in this month:
      date.setYMD(year, date.month(), 1);
      date.setYMD(year, date.month(), TQMIN(day, date.daysInMonth()));
      // ----- set this month
      setDate(date);
    } else {
      KNotifyClient::beep();
    }
  delete popup;
}

void
CalendarPanel::setEnabled(bool enable)
{
  TQWidget *widgets[]= {
    yearForward, yearBackward, monthForward, monthBackward,
    selectMonth, selectYear,
    line, table, d->selectWeek };
  const int Size=sizeof(widgets)/sizeof(widgets[0]);
  int count;
  // -----
  for(count=0; count<Size; ++count)
    {
      widgets[count]->setEnabled(enable);
    }
    table->setEnabled(enable);
}

void
CalendarPanel::lineEnterPressed()
{
  TQDate temp;
  // -----
  if(val->date(line->text(), temp)==TQValidator::Acceptable)
    {
        //kdDebug() << "CalendarPanel::lineEnterPressed: valid date entered." << endl;
        emit(dateEntered(temp));
        setDate(temp);
    } else {
      KNotifyClient::beep();
      //kdDebug() << "CalendarPanel::lineEnterPressed: invalid date entered." << endl;
    }
}

TQSize
CalendarPanel::sizeHint() const
{
  TQSize tableSize=table->sizeHint();
  TQWidget *buttons[]={
    yearBackward,
    monthBackward,
    selectMonth,
    selectYear,
    monthForward,
    yearForward,
    d->closeButton
  };
  const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
  TQSize sizes[NoOfButtons];
  int cx=0, cy=0, count;
  // ----- store the size hints:
    for(count=0; count<NoOfButtons; ++count) {
        if ( buttons[count] )
            sizes[count]=buttons[count]->sizeHint();
        else
            sizes[count] = TQSize(0,0);

        if(buttons[count]==selectMonth) {
	        TQSize metricBound = style().tqsizeFromContents(TQStyle::CT_ToolButton, selectMonth, maxMonthRect);
            cx+=TQMAX(metricBound.width(), maxMonthRect.width()+2*TQApplication::style().pixelMetric(TQStyle::PM_ButtonMargin));
    	} else {
	        cx+=sizes[count].width();
	    }
        cy=TQMAX(sizes[count].height(), cy);
    }
    // ----- calculate width hint:
    cx=TQMAX(cx, tableSize.width()); // line edit ignored
    // ----- calculate height hint:
    cy+=tableSize.height()+line->sizeHint().height();
    return TQSize(cx, cy);
}

void
CalendarPanel::setFontSize(int s)
{
  TQWidget *buttons[]= {
    // yearBackward,
    // monthBackward,
    selectMonth,
    selectYear,
    // monthForward,
    // yearForward
  };
  const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
  int count;
  TQFont font;
  TQRect r;
  // -----
  fontsize=s;
  for(count=0; count<NoOfButtons; ++count)
    {
      font=buttons[count]->font();
      font.setPointSize(s);
      buttons[count]->setFont(font);
    }
  TQFontMetrics metrics(selectMonth->fontMetrics());
  for(int i=1; i <= 12; ++i)
    { // maxMonthRect is used by sizeHint()
      r=metrics.boundingRect(TDEGlobal::locale()->calendar()->monthName(i, false));
      maxMonthRect.setWidth(TQMAX(r.width(), maxMonthRect.width()));
      maxMonthRect.setHeight(TQMAX(r.height(),  maxMonthRect.height()));
    }
  table->setFontSize(s);
}

void
CalendarPanel::setCloseButton( bool enable )
{
    if ( enable == (d->closeButton != 0L) )
        return;

    if ( enable ) {
        d->closeButton = new TQToolButton( this );
        TQToolTip::add(d->closeButton, i18n("Close"));
        d->closeButton->setPixmap( SmallIcon("remove") );
        connect( d->closeButton, TQT_SIGNAL( clicked() ),
                 topLevelWidget(), TQT_SLOT( close() ) );
    }
    else {
        delete d->closeButton;
        d->closeButton = 0L;
    }
    
    updateGeometry();
}

bool CalendarPanel::hasCloseButton() const
{
    return (d->closeButton != 0L);
}

int CalendarPanel::weekOfYear(TQDate date)
{
    // Calculate ISO 8601 week number (taken from glibc/Gnumeric)
    int year, week, wday, jan1wday, nextjan1wday;
    TQDate jan1date, nextjan1date;

    year=date.year();
    wday=date.dayOfWeek();

    jan1date=TQDate(year,1,1);
    jan1wday=jan1date.dayOfWeek();

    week = (date.dayOfYear()-1 + jan1wday-1)/7 + ((jan1wday-1) == 0 ? 1 : 0);

    /* Does date belong to last week of previous year? */
    if ((week == 0) && (jan1wday > 4 /*THURSDAY*/)) {
        TQDate tmpdate=TQDate(year-1,12,31);
        return weekOfYear(tmpdate);
    }

    if ((jan1wday <= 4 /*THURSDAY*/) && (jan1wday > 1 /*MONDAY*/))
        week++;

    if (week == 53) {
        nextjan1date=TQDate(year+1, 1, 1);
        nextjan1wday = nextjan1date.dayOfWeek();
        if (nextjan1wday <= 4 /*THURSDAY*/)
            week = 1;
    }

    return week;
}

void CalendarPanel::slotWeekdaySelected(int day) {
    //kdDebug()<<k_funcinfo<<endl;
    emit weekdaySelected(day);
}

void CalendarPanel::slotWeekSelected(int week, int year) {
    //kdDebug()<<k_funcinfo<<endl;
    emit weekSelected(week, year);
}

void CalendarPanel::setCalendar(Calendar *cal) {
    //kdDebug()<<k_funcinfo<<endl;
    table->clear();
    if (cal) {
        table->setMarkedWeekdays(cal->weekdaysMap());
        TQPtrListIterator<CalendarDay> it = cal->days();
        //kdDebug()<<k_funcinfo<<"Days="<<it.count()<<endl;
        for (; it.current(); ++it) {
            if (it.current()->state() != Map::None) {
                table->addMarkedDate(it.current()->date(), it.current()->state());
            //kdDebug()<<k_funcinfo<<"Added day: "<<it.current()->date().toString()<<"="<<it.current()->state()<<endl;
            }
        }
        setEnabled(true);
        table->setFocus();
    }
}

DateMap  CalendarPanel::selectedDates() {
    return table->selectedDates();
}

IntMap  CalendarPanel::selectedWeekdays() {
    return table->selectedWeekdays();
}

DateMap  CalendarPanel::markedDates() {
    return table->markedDates();
}

IntMap  CalendarPanel::markedWeekdays() {
    return table->markedWeekdays();
}

void CalendarPanel::clear() {
    table->clear();
    setEnabled(false);
}

void CalendarPanel::markSelected(int state) {
    table->markSelected(state);
 }

void CalendarPanel::slotSelectionCleared() {
    emit selectionCleared();
 }

void CalendarPanel::virtual_hook( int /*id*/, void* /*data*/ )
{ /*BASE::virtual_hook( id, data );*/ }

}  //KPlato namespace

#include "kptcalendarpanel.moc"
