// This Source Code is Copyright & Licenced as indicated below
package org.litesoft.GWT.forms.client.components.nonpublic.datepicker.impl;
/*
 * Copyright 2007 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

import com.google.gwt.i18n.client.*;
import com.google.gwt.user.client.ui.*;

import java.util.*;

/**
 * LocaleCalendarUtils public class provides all the tables required to display
 * the calendar grid for a month with respect to a locale. It also provides
 * methods to obtain following data:
 * <p/>
 * <ul>
 * <li>Names for days of month</li>
 * <li>Month and year names for the title of DatePicker </li>
 * <li>Sequence order of year and month </li>
 * <li>Weekend dates </li>
 * <li>Week number of the year for weeks </li>
 * <li>Starting day of the Week </li>
 * <li>List of month names of the year</li>
 * <li>List of years to be displayed</li>
 * <li>Long name for today</li>
 * <li>Position of the month start in the calendar grid</li>
 * </ul>
 * <p/>
 * Following calendar manipulation methods:
 * <ul>
 * <li>Adding months to current date</li>
 * <li>Setting a specific date, month or year</li>
 * <li>Returning user specified date</li>
 * <li>Enabling display of trailing and leading dates from adjacent months</li>
 * </ul>
 * <p/>
 * Following methods for styling specific dates:
 * <ul>
 * <li>Adding a date for styling with its CSS style name</li>
 * <li>Number of dates with special styles</li>
 * </ul>
 */
public class LocaleCalendarUtils extends DatePickerDate {

    /**
     * Constant SELECTED represents the user selected date in the grid.
     */
    public static final int SELECTED = 0;

    /**
     * Constant TODAY represents today's date in the grid.
     */
    public static final int TODAY = 1;

    /**
     * Constant TYPE_PREV_MONTH represents the grid cells for the month previous
     * to currently displayed one.
     */
    public static final int TYPE_PREV_MONTH = -1;

    /**
     * Constant TYPE_CURR_MONTH represents the grid cells for
     * currently displayed month.
     */
    public static final int TYPE_CURR_MONTH = 0;

    /**
     * Constant TYPE_NEXT_MONTH represents the grid cells for the month next
     * to currently displayed one.
     */
    public static final int TYPE_NEXT_MONTH = 1;

    /**
     * Constant TYPE_CONTROL represents the grid cell representing a control.
     */
    public static final int TYPE_CONTROL = 2;

//    private static final DateTimeConstants intlConstants = (DateTimeConstants) GWT.create( DateTimeConstants.class );

    /**
     * dayOfWeekNames is kept as strings because used only once
     * for initial drawing.
     */
    private static final String[] dayOfWeekNames = new String[7];

    private static final DateTimeFormat dayOfMonthFormatter = DateTimeFormat.getFormat( "d" );
    private static final DateTimeFormat yearFormatter = DateTimeFormat.getFormat( "yyyy" );
    private static final DateTimeFormat monthFormatter = DateTimeFormat.getFormat( "MMM" );
    private static final DateTimeFormat dayOfWeekFormatter = DateTimeFormat.getFormat( "ccccc" );
    private static final DateTimeFormat weekOfYearFormatter = DateTimeFormat.getFormat( "w" );
    private static final DateTimeFormat fullDateFormatter = DateTimeFormat.getFullDateFormat();

    private static boolean isYearBeforeMonth;
//    private static int weekendStart;
//    private static int weekendEnd;

    /**
     * Public method dayOfWeekNames() returns an array of the names for
     * days of a week in the default locale.
     *
     * @return array of size 7 with names for days of a week in the locale
     */
    public static String[] dayOfWeekNames() {
        return dayOfWeekNames;
    }

    private DatePickerCell monthName = new DatePickerCell();
    private DatePickerCell yearName = new DatePickerCell();

    private ListBox monthNames = new ListBox();
    private ListBox yearNames = new ListBox();
    private DatePickerCell todayCell;

    private DatePickerCell[] dayOfMonthNames;
    private DatePickerCell[] dayOfMonthNamesPrev;
    private DatePickerCell[] dayOfMonthNamesNext;

    private boolean adjacentMonths;

    private int currMonthSize;
    private int prevMonthDays;
    private int nextMonthDays;
    private int gridStart;

    private Vector specialDates = new Vector();

    /**
     * Public constructor for LocaleCalendarUtils class. It takes in
     * a boolean parameter indicating whether to display some dates
     * from adjacent months.
     */

    public LocaleCalendarUtils( boolean adjacentMonths ) {

        // Finding day of month names
        dayOfMonthNames = new DatePickerCell[31];

        Date date = new Date();
        date.setMonth( 0 );

        for ( int i = 0; i < 31; ++i ) {
            date.setDate( i + 1 );
            dayOfMonthNames[i] = new DatePickerCell( dayOfMonthFormatter.format( date ), 0, i + 1 );
        }

        dayOfMonthNamesPrev = createShadow( dayOfMonthNames, TYPE_PREV_MONTH );
        dayOfMonthNamesNext = createShadow( dayOfMonthNames, TYPE_NEXT_MONTH );

        // Finding day of week names
        for ( int i = 1; i <= 7; i++ ) {
            date.setDate( i );
            int dayOfWeek = date.getDay();
            dayOfWeekNames[dayOfWeek] = dayOfWeekFormatter.format( date );
        }

        // Finding whether year is before month
//        String[] dateFormats = intlConstants.dateFormats();
//        String dateLongFormat = dateFormats[3];

//        int yIndex = dateLongFormat.indexOf( "y" );
//        int mIndex = dateLongFormat.indexOf( "M" );

        isYearBeforeMonth = false; // (yIndex < mIndex);

        // Finding the start and end of weekend
//        weekendStart = Integer.parseInt( intlConstants.weekendRange()[0] ) - 1;
//        weekendEnd = Integer.parseInt( intlConstants.weekendRange()[1] ) - 1;

        // Finding the list of year names and the name of the current year
        Date year = new Date();
        for ( int y = 0; y < 120; y++ ) {
            year.setYear( y );
            yearNames.addItem( yearFormatter.format( year ) );
            yearNames.setValue( y, Integer.toString( y ) );
        }
        yearNames.setSelectedIndex( this.getYear() );
        yearName.setText( yearFormatter.format( this ) );

        // Finding the list of month names and the name of the current month
        date = DatePickerDate.getDateAtMonthStart();

        for ( int i = 0; i < 12; i++ ) {
            date.setMonth( i );
            String monthStr = monthFormatter.format( date );
            monthNames.addItem( monthStr );
            monthNames.setValue( i, Integer.toString( i ) );
        }

        monthNames.setSelectedIndex( this.getMonth() );
        monthName.setText( monthFormatter.format( this ) );

        // Finding today's date string
        Date today = DatePickerDate.getDateAtDayStart();
        todayCell = new DatePickerCell( fullDateFormatter.format( today ) );
        todayCell.setType( TYPE_CONTROL );
        setSpecialDay( SELECTED, this );
        setSpecialDay( TODAY, today );

        this.adjacentMonths = adjacentMonths;

        populateDatePickerGrid();
    }

    /**
     * Public method addMonths() add a positive or negative number to the date.
     * The day of the month will be pinned to the original value
     * as far as possible.
     *
     * @param delta - number of months to be added to the current date
     *
     * @return boolean - indicate whether change in year value happened or not
     */
    @Override
    public boolean addMonths( int delta ) {
        if ( delta == 0 ) {
            return false;
        }

        boolean yearChanged = super.addMonths( delta );
        changeMonthYearStr( yearChanged );
        populateDatePickerGrid();
        return yearChanged;
    }

    /**
     * Public method addSpecialDay() add a date to the list of special dates
     * that require special formatting.
     *
     * @param date - date that require special formatting
     */
    public DatePickerDate addSpecialDay( Date date ) {

        return setSpecialDay( specialDates.size(), date );
    }

    /**
     * Public method dayOfMonthNames() returns an array of labels for
     * days of a month in the default locale.
     *
     * @return array of size 31 with names for days of month in default locale
     */
    public DatePickerCell[] dayOfMonthNames() {

        return dayOfMonthNames;
    }

    /**
     * Public method dayOfMonthNamesNext() returns an array of labels for
     * days of the next month in the default locale.
     *
     * @return array of size 31 with names for days of the next month
     * in the default locale
     */
    public DatePickerCell[] dayOfMonthNamesNext() {
        return dayOfMonthNamesNext;
    }

    /**
     * Public method dayOfMonthNamesPrev() returns an array of labels for
     * days of the previous month in the default locale.
     *
     * @return array of size 31 with names for days of the previous month
     * in the default locale
     */
    public DatePickerCell[] dayOfMonthNamesPrev() {
        return dayOfMonthNamesPrev;
    }

    /**
     * Public method enableAdjacentMonths() enables or disables the display of
     * trailing and leading dates from previous and next months.
     *
     * @param adjacentMonths - A boolean indicating whether display of trailing
     *                       and leading dates from previous and next months.
     */
    public void enableAdjacentMonths( boolean adjacentMonths ) {
        this.adjacentMonths = adjacentMonths;
        populateConstants();
    }

    /**
     * Public method gridStart() returns the column number in the grid
     * for the month start.
     *
     * @return returns the column number in the grid
     * for the month start.
     */
    public int gridStart() {
        return gridStart;
    }

    /**
     * Public method isYearBeforeMonth() returns whether the year is before month
     * in the current locale or not.
     *
     * @return returns whether the year is before month
     * in the current locale or not.
     */
    public boolean isYearBeforeMonth() {
        return isYearBeforeMonth;
    }

    /**
     * Public method monthName() returns the name of the current month in the
     * default locale.
     *
     * @return returns the name of the current month in the
     * default locale.
     */
    public Label monthName() {
        return monthName;
    }

    /**
     * Public method monthNames() returns a ListBox containing the 12 month names
     * in the default locale. Current month would be the set as selected.
     *
     * @return returns a ListBox containing the 12 month names
     * in the default locale.
     */
    public ListBox monthNames() {
        return monthNames;
    }

    /**
     * Public method nextMonthDays() returns number of days in the next month.
     *
     * @return number of days in the next month.
     */
    public int nextMonthDays() {
        return nextMonthDays;
    }

    /**
     * Public method numSpecialDays() returns number of dates for which special
     * formatting is set.
     *
     * @return number of number of dates for which special
     * formatting is set.
     */
    public int numSpecialDays() {
        return specialDates.size();
    }

    /**
     * Public method prevMonthDays() returns number of days in the previous month.
     *
     * @return number of days in the previous month.
     */
    public int prevMonthDays() {
        return prevMonthDays;
    }

    /**
     * Public method selectedDate() sets the date user selected.
     *
     * @param monthType  - Month type of the cell in which user clicked. Type can
     *                   be current, previous or next month.
     * @param dayOfMonth - Selected day of the month
     */
    public void selectedDate( int monthType, int dayOfMonth ) {

        if ( monthType != LocaleCalendarUtils.TYPE_CURR_MONTH ) {
            super.setDate( 1 );
            this.addMonths( monthType );
            populateConstants();
        }

        super.setDate( dayOfMonth );
        updateSpecialDays();
    }

    /**
     * Public method selectedDate() sets to the given date.
     *
     * @param date - Date to be set.
     */
    @Override
    public void setFullDate( Date date ) {
        super.setFullDate( date );
        changeMonthYearStr( true );
        populateDatePickerGrid();
    }

    /**
     * Public method setMonth() sets to the given month.
     *
     * @param month - Month to be set.
     */
    @Override
    public void setMonth( int month ) {
        super.setMonth( month );
        populateDatePickerGrid();
        changeMonthYearStr( false );
    }

    /**
     * Public method setToday() sets date to today's date. The tables exported
     * by this class are changed accordingly.
     *
     * @return Boolean reflecting whether year has been changed or not.
     */
    @Override
    public boolean setToday() {
        boolean yearChanged = super.setToday();
        populateDatePickerGrid();
        changeMonthYearStr( yearChanged );
        return yearChanged;
    }

    /**
     * Public method setYear() sets to the given year.
     *
     * @param year - Year to be set.
     */
    @Override
    public void setYear( int year ) {
        super.setYear( year );
        populateDatePickerGrid();
        changeMonthYearStr( true );
    }

    /**
     * Public method specialDate() returns a date from the list of dates
     * that require special formatting.
     *
     * @param i - position of the date entry in the special date list.
     */
    public DatePickerDate specialDate( int i ) {
        return (DatePickerDate) specialDates.get( i );
    }

    /**
     * Public method todayCell() returns the Label for the cell displaying today's
     * date.
     */
    public DatePickerCell todayCell() {
        return todayCell;
    }

    /**
     * Public method weekendEnd() returns the day of the week on which
     * weekend ends.
     * The range between 0 for Sunday and 6 for Saturday.
     *
     * @return the day of the week on which weekend ends.
     */
    public int weekendEnd() {

        return 0; // weekendEnd;
    }

    /**
     * Public method weekendStart() returns the day of the week on which
     * weekend starts.
     * The range between 0 for Sunday and 6 for Saturday.
     *
     * @return the day of the week on which weekend starts.
     */
    public int weekendStart() {
        return 6; // weekendStart;
    }

    /**
     * Public method weekOfYear() returns a list of strings for week number of
     * the year for the weeks displayed as per the locale set.
     *
     * @return List of strings for week number of
     * the year for the weeks displayed as per the locale set.
     */
    public String[] weekOfYear() {

        String[] weekOfYear = new String[7];
        Date date = (Date) this.clone();

        for ( int i = 1 - prevMonthDays; i < currMonthSize + nextMonthDays; i += 7 ) {
            date.setDate( i );
            weekOfYear[i] = weekOfYearFormatter.format( date );
        }

        return weekOfYear;
    }

    /**
     * Public method weekStart() returns the day of the week on which
     * week starts as per the locale.
     * The range between 0 for Sunday and 6 for Saturday.
     *
     * @return the day of the week on which week starts as per the locale.
     */
    public int weekStart() {
        return 0; // Integer.parseInt( intlConstants.firstDayOfTheWeek() ) - 1;
    }

    /**
     * Public method yearName() returns the name of the current year in the
     * default locale.
     *
     * @return returns the name of the current year in the
     * default locale.
     */
    public Label yearName() {
        return yearName;
    }

    /**
     * Public method yearNames() returns a ListBox containing the 120 year names
     * in the default locale. Current year would be the set as selected.
     *
     * @return returns a ListBox containing the 120 year names
     * in the default locale.
     */
    public ListBox yearNames() {

        return yearNames;
    }

    private void changeMonthYearStr( boolean yearChanged ) {
        monthName.setText( monthFormatter.format( this ) );
        monthNames.setSelectedIndex( this.getMonth() );

        if ( yearChanged ) {
            yearName.setText( yearFormatter.format( this ) );
            yearNames.setSelectedIndex( this.getYear() );
        }
    }

    private DatePickerCell[] createShadow( DatePickerCell[] original, int monthType ) {

        DatePickerCell[] shadow = new DatePickerCell[31];

        for ( int i = 0; i < 31; ++i ) {
            shadow[i] = original[i].copy();
            shadow[i].setType( monthType );
        }

        return shadow;
    }

    private void populateConstants() {

        int weekStart = this.weekStart();
        int dayOfWeek = super.getDay();
        int date = super.getDate();
        int month = super.getMonth();
        int year = super.getYear();
        // offset from Sunday == 0; +70 to make number +ve
        int offset = (dayOfWeek - date + 1 - weekStart + 70) % 7;
        int monthCount = year * 12 + month;

        currMonthSize = super.currMonthSize();

        if ( adjacentMonths ) {
            prevMonthDays = (monthCount > 0) ? (offset + 7) : 0; // for Jan 1900
            nextMonthDays = (monthCount < 120 * 12 - 1) ? (7 * 7 - prevMonthDays - currMonthSize) : 0; // <= Dec 2019
            gridStart = 0;
        } else {
            prevMonthDays = 0;
            nextMonthDays = 0;
            gridStart = offset;
        }
    }

    private void populateDatePickerGrid() {

        populateConstants();
        updateSpecialDays();
    }

    private DatePickerDate setSpecialDay( int i, Date d ) {
        DatePickerDate day;
        if ( i >= specialDates.size() ) {
            day = new DatePickerDate( d );
            specialDates.add( i, day );
        } else {
            day = (DatePickerDate) specialDates.get( i );
            day.setFullDate( d );
        }
        day.setDayDiff( this, this.getDate() - 1 );

        return day;
    }

    private void updateSpecialDays() {

        int dayOfMonth = this.getDate();
        this.setSpecialDay( SELECTED, this );

        Iterator it = specialDates.iterator();
        while ( it.hasNext() ) {
            DatePickerDate d = (DatePickerDate) it.next();
            d.setDayDiff( this, dayOfMonth - 1 );
        }
    }
}