package caltool.model.schedule;

import caltool.model.caldb.*;
import mvp.*;

/****
 *
 * Class Schedule is the top-level model class in the schedule package.  It
 * provides methods to schedule the four types of calendar item.  It also
 * contains a Categories data field, which is the sub-model for editing
 * scheduled item categories.
 *
 * @author Gene Fisher (gfisher@calpoly.edu)
 * @version 23jan13
 *
 */
public class Schedule extends Model {

    /**
     * Construct this with the given companion view and the parent CalendarDB
     * model.  The CalendarDB is provided to access to its service methods that
     * store items in the current user calendar.
     *                                                                     <pre>
      post:
        this.view == view &&
        this.calDB == calDB;
     */
    public Schedule(View view, CalendarDB calDB) {
        super(view);
        this.calDB = calDB;
    }

    /*-*
     * Derived methods
     */

    /**
     * ScheduleAppointment adds the given Appointment to the current Calendar
     * an appointment of the same time, duration, and title is not already
     * scheduled.
     *                                                                     <pre>
      pre:
        //
        // The Title field is not empty.
        //
        (appt.title != null && appt.title.length() >= 1)

            &&

        //
        // The startOrDueDate field is a valid date value.
        //
        ((appt.startOrDueDate != null) && appt.startOrDueDate.isValid())

            &&

        //
        // If non-empty, the EndDate field is a valid date value.
        //
        ((appt.endDate != null) || appt.endDate.isValid())

            &&

        //
        // The current workspace is not null.
        //
        (calDB.getCurrentCalendar() != null)

            &&

        //
        // No appt of same title and start date is in the current workspace
        // calendar.  The UserCalendar.getItem method does the work.
        //
        calDB.getCurrentCalendar().getItem(appt.getKey()) == null;

      post:
        //
        // If preconds met, a scheduled item is in the output calendar if
        // and only if it is the new appt to be added or it is in the 
        // input calendar.
        //
        forall (ScheduledItem item;
            calDB'.getCurrentCalendar().getItem(item.getKey()) != null iff
                (item.equals(appt) ||
                 calDB.getCurrentCalendar().getItem(item.getKey()) != null));

     */
    public void scheduleAppointment(Appointment appt) {
        System.out.println("In Schedule.scheduleAppointment.");
    }

    /**
     * ScheduleMeeting adds a Meeting to the current calendar, based on the the
     * given MeetingRequest.  The work is done by the three suboperations,
     * which determine a list of possible meetings times, set
     * meeting-scheduling options, and confirm the scheduling of a specific
     * meeting selected from the possibles list.
     */
    public void scheduleMeeting(MeetingRequest meeting_req) {
        System.out.println("In Schedule.scheduleMeeting.");
    }

    /**
     * Produce the list of possible meeting times that satisfy the given
     * MeetingRequest.
     */
    public PossibleMeetingTimes listMeetingTimes(MeetingRequest request) {
        System.out.println("In schedule.listMeetingTimes.");
        return null;
    }

    /**
     * Set the meeting options in the CalendarDB to those given.
     * 
     */
    public void setMeetingOptions(MeetingSchedulingOptions options) {
        System.out.println("In schedule.setMeetingOptions.");
    }

    /**
     * ConfirmMeeting takes a CalendarDB, MeetingRequest, list of
     * PossibleMeetingTimes, and a selected time from the list.  It outputs a
     * new CalendarDB with the given request scheduled at the selected time.
     */
    public void confirmMeeting(MeetingRequest meeting_req,
            PossibleMeetingTimes possible_times, int selected_time) {
        System.out.println("In Schedule.confirmMeeting");
    }

    /**
     * ScheduleTask adds the given Task to the given CalendarDB, if a task of
     * the same start date, title, and priority is not already scheduled.
     */
    public void scheduleTask(Task task) {
        System.out.println("In Schedule.scheduleTask.");
    }

    /**
     * ScheduleEvent adds the given Event to the given CalendarDB, if an event
     * of the same start date and title is not already scheduled.
     *                                                                     <pre>
      pre:
        //
        // The Title field is not empty.
        //
        (event.title != null && event.title.length() >= 1)

            &&

        //
        // The startOrDueDate field is a valid date value.
        //
        (event.startOrDueDate != null) && event.startOrDueDate.isValid()

            &&

        //
        // If non-empty, the EndDate field is a valid date value.
        //
        (event.endDate != null) ==> event.endDate.isValid()

            &&

        //
        // The current workspace is not null.
        //
        (calDB.getCurrentCalendar() != null)

            &&

        //
        // No event of same title and start date is in the current workspace
        // calendar.  The UserCalendar.getItem method does the work.
        //
        calDB.getCurrentCalendar().getItem(event.getKey()) == null;

      post:
        //
        // If preconds met, a scheduled item is in the output calendar if
        // and only if it is the new appt to be added or it is in the 
        // input calendar.  Note that this is a refined version of the original
        // more abstract spec, to make this spec more implementable.
        //
        forall (ScheduledItem item;
            calDB.getCurrentCalendar().getItems().contains(item) iff
                item.equals(event) ||
                   calDB.getCurrentCalendar().getItems().contains(item))

            &&

        //
        // Check that the size of the number of items in the output calendar is
        // one greater than the input calendar.  This conjoin is new here
        // compared to the original abstract spec.  Its addition, together with
        // the uniqueness condition being met ensure no junk and no confusion.
        // The reader should convince her or himself that this is the case.
        //
        (calDB'.getCurrentCalendar().getItems().size() ==
            calDB.getCurrentCalendar().getItems().size() + 1);

     */
    public void scheduleEvent(Event event) throws ScheduleEventPrecondViolation {
        System.out.println("In Schedule.scheduleEvent.");
    }

    /**
     * Change the given old appointment to the given new one in the
     * current calendar.
     */
    public void changeAppointment(Appointment oldAppt, Appointment newAppt) {
        System.out.println("In Schedule.changeAppointment.");
    }

    /**
     * Delete the given appointment from the current calendar.
     */
    public void deleteAppointment(Appointment appt) {
        System.out.println("In Schedule.deleteAppointment.");
    }


    /**
     * Set the priority of the given task to the given priority value.  The
     * value must be between 0 and 10, inclusive.  Throw an exception if it's
     * not in this range.
     *                                                                     <pre>
      pre:
        priority >= 0 && priority <= 10;

      post:
        task.priority == priority;
     */
    public void setTaskPriority(Task task, int priority) {}


    /*-*
     * Access methods
     */

    /**
     * Return the categories component.
     */
    public Categories getCategories() {
        return categories;
    }


    /*-*
     * Derived data fields
     */

    /** Category list in which scheduled item categories are defined */
    protected Categories categories;


    /*-*
     * Process data fields
     */

    /** Calendar database in which scheduled items are stored */
    protected CalendarDB calDB;

}