/*
 * Copyright (C) 2008 Emweb bv, Herent, Belgium.
 *
 * See the LICENSE file for terms of use.
 */

#include "Wt/WApplication.h"
#include "Wt/WEnvironment.h"
#include "Wt/WCalendar.h"

#include "Wt/WComboBox.h"
#include "Wt/WInPlaceEdit.h"
#include "Wt/WLineEdit.h"
#include "Wt/WLogger.h"
#include "Wt/WStringStream.h"
#include "Wt/WTemplate.h"
#include "Wt/WText.h"

#include "WebUtils.h"

namespace Wt {

LOGGER("WCalendar");

// Because WDate returns days and weeks as WT_USTRING, we need this:
#ifndef WT_TARGET_JAVA
#define DATE_NAME_STR(e) e
#else
#define DATE_NAME_STR(e) WString::fromUTF8(e)
#endif

WCalendar::WCalendar()
{
  create();
  impl_->addStyleClass("Wt-calendar");
}

void WCalendar::setSelectionMode(SelectionMode mode)
{
  if (selectionMode_ != mode) {
    if (mode != SelectionMode::Extended && selection_.size() > 1) {
      selection_.clear();
      renderMonth();
    }
    selectionMode_ = mode;
  }
}

void WCalendar::setSingleClickSelect(bool single)
{
  singleClickSelect_ = single;
}

void WCalendar::create()
{
  selectionMode_ = SelectionMode::Single;
  singleClickSelect_ = false;
  horizontalHeaderFormat_ = CalendarHeaderFormat::ShortDayNames;
  firstDayOfWeek_ = 1;

  WDate currentDay = WDate::currentDate();

  currentYear_ = currentDay.year();
  currentMonth_ = currentDay.month();

  WStringStream text;

  text <<
    "<table class=\"days ${table-class}\" cellspacing=\"0\" cellpadding=\"0\">"
    """<tr>"
    ""  "<th class=\"caption\">${nav-prev}</th>"
    ""  "<th class=\"caption\"colspan=\"5\">${month} ${year}</th>"
    ""  "<th class=\"caption\">${nav-next}</th>"
    """</tr>"
    """<tr>";

  for (int j = 0; j < 7; ++j)
    text <<
      "<th title=\"${t" << j << "}\" scope=\"col\">${d" << j << "}</th>";

  text << "</tr>";

  for (int i = 0; i < 6; ++i) {
    text << "<tr>";
    for (int j = 0; j < 7; ++j)
      text << "<td>${c" << (i * 7 + j) << "}</td>";
    text << "</tr>";
  }

  text << "</table>";

  std::unique_ptr<WTemplate> t(new WTemplate());
  impl_ = t.get();
  setImplementation(std::move(t));
  impl_->setTemplateText(WString::fromUTF8(text.str()),
                         TextFormat::UnsafeXHTML);
  impl_->setStyleClass("Wt-cal");

  setSelectable(false);

  std::unique_ptr<WText> prevMonth(new WText(tr("Wt.WCalendar.PrevMonth")));
  prevMonth->setStyleClass("Wt-cal-navbutton");
  prevMonth->clicked().connect(this, &WCalendar::browseToPreviousMonth);

  std::unique_ptr<WText> nextMonth(new WText(tr("Wt.WCalendar.NextMonth")));
  nextMonth->setStyleClass("Wt-cal-navbutton");
  nextMonth->clicked().connect(this, &WCalendar::browseToNextMonth);

  std::unique_ptr<WComboBox> monthEdit(new WComboBox());
  monthEdit_ = monthEdit.get();

  monthEdit->setInline(true);
  for (unsigned i = 0; i < 12; ++i)
    monthEdit->addItem(WDate::longMonthName(i+1));
  monthEdit->activated().connect(this, &WCalendar::monthChanged);
  monthEdit->setDisabled(!WApplication::instance()->environment().ajax());

  std::unique_ptr<WInPlaceEdit> yearEdit(new WInPlaceEdit(""));
  yearEdit_ = yearEdit.get();

  yearEdit->setButtonsEnabled(false);
  yearEdit->lineEdit()->setTextSize(4);
  yearEdit->setStyleClass("Wt-cal-year");
  yearEdit->valueChanged().connect(this, &WCalendar::yearChanged);

  impl_->bindWidget("nav-prev", std::move(prevMonth));
  impl_->bindWidget("nav-next", std::move(nextMonth));
  impl_->bindWidget("month", std::move(monthEdit));
  impl_->bindWidget("year", std::move(yearEdit));

  setHorizontalHeaderFormat(horizontalHeaderFormat_);
  setFirstDayOfWeek(firstDayOfWeek_);
}

void WCalendar::enableAjax()
{
  WCompositeWidget::enableAjax();
  monthEdit_->enable();

}

void WCalendar::load()
{
  WCompositeWidget::load();
  if(WApplication::instance()->environment().ajax()){
    monthEdit_->enable();
  }
}

void WCalendar::setFirstDayOfWeek(int dayOfWeek)
{
  firstDayOfWeek_ = dayOfWeek;

  for (unsigned i = 0; i < 7; ++i) {
    int day = (i + firstDayOfWeek_ - 1) % 7 + 1;

    WString title = WDate::longDayName(day);
    impl_->bindString("t" + std::to_string(i),
                      title,
                      TextFormat::UnsafeXHTML);

    WString abbr;
    switch (horizontalHeaderFormat_) {
    case CalendarHeaderFormat::SingleLetterDayNames:
      abbr = WString::fromUTF8(WDate::shortDayName(day).toUTF8().substr(0, 1));
      break;
    case CalendarHeaderFormat::ShortDayNames:
      abbr = WDate::shortDayName(day);
      break;
    case CalendarHeaderFormat::LongDayNames:
      abbr = WDate::longDayName(day);
      break;
    }

    impl_->bindString("d" + std::to_string(i), abbr,
                      TextFormat::UnsafeXHTML);
  }

  renderMonth();
}

void WCalendar::setHorizontalHeaderFormat(CalendarHeaderFormat format)
{
  std::string d;
  switch (format) {
  case CalendarHeaderFormat::SingleLetterDayNames:
    d = "d1"; break;
  case CalendarHeaderFormat::ShortDayNames:
    d = "d3"; break;
  case CalendarHeaderFormat::LongDayNames:
    d = "dlong"; break;
  default:
    LOG_ERROR("setHorizontalHeaderFormat(): "
              "improper horizontal header format.");
    format = CalendarHeaderFormat::SingleLetterDayNames;
    d = "d1";
  }

  horizontalHeaderFormat_ = format;

  impl_->bindString("table-class", d, TextFormat::UnsafeXHTML);

  setFirstDayOfWeek(firstDayOfWeek_);
}

void WCalendar::renderMonth()
{
  needRenderMonth_ = true;

  if (isRendered())
    scheduleRender();
}

void WCalendar::render(WFlags<RenderFlag> flags)
{
  if (needRenderMonth_) {
#ifndef WT_TARGET_JAVA
    char buf[30];
#else
    char *buf;
#endif // WT_TARGET_JAVA

    int m = currentMonth_ - 1;
    if (monthEdit_->currentIndex() != m)
      monthEdit_->setCurrentIndex(m);

    int y = currentYear_;
    Utils::itoa(y, buf);
    if (yearEdit_->text().toUTF8() != buf)
      yearEdit_->setText(WString::fromUTF8(buf));

    // The first line contains the last day of the previous month.
    WDate d(currentYear_, currentMonth_, 1);
    d = d.addDays(-1);

    d = WDate::previousWeekday(d, firstDayOfWeek_);

    for (unsigned i = 0; i < 6; ++i) {
      for (unsigned j = 0; j < 7; ++j) {
        Utils::itoa(i * 7 + j, buf);
        std::string cell = std::string("c") + buf;

        WDate date(d.year(), d.month(), d.day());

        WWidget *w = impl_->resolveWidget(cell);
        WWidget *rw = renderCell(w, date);
        WInteractWidget* iw = dynamic_cast<WInteractWidget*>(rw->webWidget());

        if (rw != w)
          impl_->bindWidget(cell, std::unique_ptr<WWidget>(rw));

        if (iw && iw != w) {
          if (clicked().isConnected()
              || (selectionMode_ == SelectionMode::Extended)
              || (selectionMode_ != SelectionMode::Extended &&
                  singleClickSelect_ && activated().isConnected())) {
            const Coordinate c(i, j);
            iw->clicked().connect
              (this,
               std::bind(&WCalendar::cellClicked, this, c));
          }

          if ((selectionMode_ != SelectionMode::Extended &&
               !singleClickSelect_ && (activated().isConnected() ||
                   selectionChanged().isConnected()))) {
            const Coordinate c(i, j);
            iw->doubleClicked().connect
              (this,
               std::bind(&WCalendar::cellDblClicked, this, c));
          }
        }

    d = d.addDays(1);
      }
    }

    needRenderMonth_ = false;
  }

  WCompositeWidget::render(flags);
}

WWidget *WCalendar::renderCell(WWidget* widget, const WDate& date)
{
  WText* t = dynamic_cast<WText*>(widget);

  if (!t) {
    t = new WText();
    t->setInline(false);
    t->setTextFormat(TextFormat::Plain);
  }

#ifndef WT_TARGET_JAVA
    char buf[30];
#else
    char *buf;
#endif // WT_TARGET_JAVA
  Utils::itoa(date.day(), buf);
  t->setText(WString::fromUTF8(buf));

  std::string styleClass;

  if (isInvalid(date))
    styleClass += " Wt-cal-oor";
  else if (date.month() != currentMonth())
    styleClass += " Wt-cal-oom";

  if (isSelected(date))
    styleClass += " Wt-cal-sel";

  WDate currentDate = WDate::currentDate();
  if (date.day() == currentDate.day() && date.month() == currentDate.month() &&
      date.year() == currentDate.year()) {
    if (!isSelected(date))
      styleClass += " Wt-cal-now";
    t->setToolTip(WString::tr("Wt.WCalendar.today"));
  } else
    t->setToolTip("");

  t->setStyleClass(styleClass.c_str());

  return t;
}

bool WCalendar::isSelected(const WDate& d) const
{
  return selection_.find(d) != selection_.end();
}

void WCalendar::clearSelection()
{
  selection_.clear();

  renderMonth();
}

void WCalendar::select(const WDate& date)
{
  selection_.clear();

  selection_.insert(date);
  renderMonth();
}

void WCalendar::browseTo(const WDate& date)
{
  bool rerender = false;

  if (currentYear_ != date.year()) {
    currentYear_ = date.year();
    rerender = true;
  }

  if (currentMonth_ != date.month()) {
    currentMonth_ = date.month();
    rerender = true;
  }

  if (rerender) {
    emitCurrentPageChanged();
    renderMonth();
  }
}

void WCalendar::select(const std::set<WDate>& dates)
{
  if (selectionMode_ == SelectionMode::Extended) {
    selection_ = dates;
    renderMonth();
  } else if (selectionMode_ == SelectionMode::Single) {
    if (dates.empty())
      clearSelection();
    else
      select(*dates.begin());
  }
}

void WCalendar::selectInCurrentMonth(const WDate& d)
{
  if (d.month() == currentMonth_ &&
      selectionMode_ != SelectionMode::None) {
    if (selectionMode_ == SelectionMode::Extended) {
      if (isSelected(d))
        selection_.erase(d);
      else
        selection_.insert(d);
    } else {
      selection_.clear();
      selection_.insert(d);
    }

    renderMonth();
    selectionChanged().emit();
  }
}

bool WCalendar::isInvalid(const WDate& dt)
{
  return ((!bottom_.isNull() && dt < bottom_) ||
          (!top_.isNull() && dt > top_));
}

void WCalendar::cellClicked(Coordinate weekday)
{
  WDate dt = dateForCell(weekday.i, weekday.j);
  if (isInvalid(dt))
    return;

  selectInCurrentMonth(dt);
  clicked().emit(dt);

  if (selectionMode_ != SelectionMode::Extended &&
      singleClickSelect_)
    activated().emit(dt);
}

void WCalendar::cellDblClicked(Coordinate weekday)
{
  WDate dt = dateForCell(weekday.i, weekday.j);
  if (isInvalid(dt))
    return;

  selectInCurrentMonth(dt);

  if (selectionMode_ != SelectionMode::Extended &&
      !singleClickSelect_)
    activated().emit(dt);
}

WDate WCalendar::dateForCell(int week, int dayOfWeek)
{
  WDate d(currentYear_, currentMonth_, 1);
  d = d.addDays(-1);
  d = WDate::previousWeekday(d, firstDayOfWeek_);
  d = d.addDays(week * 7 + dayOfWeek);
  return d;
}

void WCalendar::emitCurrentPageChanged()
{
  currentPageChanged().emit(currentYear_, currentMonth_);
}

void WCalendar::browseToPreviousYear()
{
  --currentYear_;

  emitCurrentPageChanged();
  renderMonth();
}

void WCalendar::browseToPreviousMonth()
{
  if (--currentMonth_ == 0) {
    currentMonth_ = 12;
    --currentYear_;
  }

  emitCurrentPageChanged();
  renderMonth();
}

void WCalendar::browseToNextYear()
{
  ++currentYear_;

  emitCurrentPageChanged();
  renderMonth();
}

void WCalendar::browseToNextMonth()
{
  if (++currentMonth_ == 13) {
    currentMonth_ = 1;
    ++currentYear_;
  }

  emitCurrentPageChanged();
  renderMonth();
}

void WCalendar::monthChanged(int newMonth)
{
  ++newMonth;

  if (currentMonth_ != newMonth
      && (newMonth >= 1 && newMonth <= 12)) {

    currentMonth_ = newMonth;

    emitCurrentPageChanged();
    renderMonth();
  }
}

void WCalendar::yearChanged(WString yearStr)
{
  try {
    int year = Utils::stoi(yearStr.toUTF8());

    if (currentYear_ != year &&
        (year >= 1900 && year <= 2200)) { // ??
      currentYear_ = year;

      emitCurrentPageChanged();
      renderMonth();
    }
  } catch (std::exception& e) {
  }
}

void WCalendar::setBottom(const WDate& bottom)
{
  if (bottom_ != bottom) {
    bottom_ = bottom;
    renderMonth();
  }
}

void WCalendar::setTop(const WDate& top)
{
  if (top_ != top) {
    top_ = top;
    renderMonth();
  }
}
}
