/*
 *  Copyright 2025 Anyware Services
 *
 *  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.
 */
package org.ametys.plugins.workspaces.calendars.task;

import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import org.apache.solr.common.SolrInputDocument;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.data.holder.IndexableDataHolder;
import org.ametys.cms.data.holder.group.IndexableComposite;
import org.ametys.cms.data.holder.group.IndexableRepeater;
import org.ametys.cms.model.CMSDataContext;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.messagingconnector.EventRecurrenceTypeEnum;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.data.external.ExternalizableDataProvider.ExternalizableDataStatus;
import org.ametys.plugins.repository.data.holder.ModifiableDataHolder;
import org.ametys.plugins.repository.data.holder.values.SynchronizationContext;
import org.ametys.plugins.repository.data.repositorydata.RepositoryData;
import org.ametys.plugins.workspaces.calendars.Calendar;
import org.ametys.plugins.workspaces.calendars.events.CalendarEvent;
import org.ametys.plugins.workspaces.calendars.events.CalendarEventOccurrence;
import org.ametys.plugins.workspaces.tasks.Task;
import org.ametys.runtime.model.Model;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.model.exception.BadDataPathCardinalityException;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.exception.UnknownTypeException;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ModelItemType;

/**
 * Object for a task calendar event
 */
public class TaskCalendarEvent implements CalendarEvent
{
    private Calendar _calendar;
    private Task _task;
    
    /**
     * The constructor
     * @param calendar the calendar
     * @param task the task
     */
    public TaskCalendarEvent(Calendar calendar, Task task)
    {
        _calendar = calendar;
        _task = task;
    }
    
    /**
     * Return the task link to the calendar event
     * @return the task
     */
    public Task getTask()
    {
        return _task;
    }
    
    public void tag(String tag) throws AmetysRepositoryException
    {
        throw new UnsupportedOperationException("Can't call method #tag for a TaskCalendarEvent");
    }

    public void untag(String tag) throws AmetysRepositoryException
    {
        throw new UnsupportedOperationException("Can't call method #untag for a TaskCalendarEvent");
    }

    public Set<String> getTags() throws AmetysRepositoryException
    {
        return _task.getTags();
    }

    public String getName() throws AmetysRepositoryException
    {
        return _task.getName();
    }

    public String getPath() throws AmetysRepositoryException
    {
        return _task.getPath();
    }

    public String getId() throws AmetysRepositoryException
    {
        return _task.getId();
    }

    public <A extends AmetysObject> A getParent() throws AmetysRepositoryException
    {
        return _task.getParent();
    }

    public String getParentPath() throws AmetysRepositoryException
    {
        return _task.getParentPath();
    }

    public Calendar getCalendar()
    {
        return _calendar;
    }
    
    public String getTitle()
    {
        return _task.getLabel();
    }

    public String getDescription()
    {
        return _task.getDescription();
    }

    public String getLocation()
    {
        return null;
    }

    public ZonedDateTime getStartDate()
    {
        LocalDate date = _task.getStartDate() != null
                ? _task.getStartDate()
                : _task.getDueDate();
        return DateUtils.asZonedDateTime(date, getZone());
    }

    public ZonedDateTime getEndDate()
    {
        LocalDate date = _task.getDueDate() != null
                ? _task.getDueDate()
                : _task.getStartDate();
        return DateUtils.asZonedDateTime(date, getZone());
    }

    public ZoneId getZone()
    {
        return ZoneId.systemDefault();
    }

    public Boolean getFullDay()
    {
        return true;
    }

    public UserIdentity getCreator()
    {
        return _task.getAuthor();
    }

    public ZonedDateTime getCreationDate()
    {
        return _task.getCreationDate();
    }

    public UserIdentity getLastContributor()
    {
        return _task.getAuthor();
    }

    public ZonedDateTime getLastModified()
    {
        return _task.getLastModified();
    }

    public EventRecurrenceTypeEnum getRecurrenceType()
    {
        return EventRecurrenceTypeEnum.NEVER;
    }

    public Boolean isRecurrent()
    {
        return false;
    }

    public ZonedDateTime getRepeatUntil()
    {
        return null;
    }

    public List<ZonedDateTime> getExcludedOccurences()
    {
        return List.of();
    }

    public List<CalendarEventOccurrence> getOccurrences(ZonedDateTime startDate, ZonedDateTime endDate)
    {
        Optional<CalendarEventOccurrence> optionalEvent = getFirstOccurrence(startDate);
        return (optionalEvent.isPresent() && optionalEvent.get().getStartDate().isBefore(endDate))
            ? List.of(optionalEvent.get())
            : List.of();
    }

    public Optional<CalendarEventOccurrence> getFirstOccurrence(ZonedDateTime date)
    {
        ZonedDateTime eventStartDate = getStartDate();
        ZonedDateTime eventEndDate = getEndDate();
        
        if (getFullDay())
        {
            eventEndDate = eventEndDate.plusDays(1);
        }
        
        return (eventEndDate.isAfter(date) || eventEndDate.isEqual(date))
            ? Optional.of(new CalendarEventOccurrence(this, eventStartDate))
            : Optional.empty();
    }

    public Optional<CalendarEventOccurrence> getNextOccurrence(CalendarEventOccurrence occurrence)
    {
        return Optional.empty();
    }

    public UserIdentity getOrganiser()
    {
        return _task.getAuthor();
    }

    public List<String> getResources()
    {
        return List.of();
    }

    public void dataToSAX(ContentHandler contentHandler, String dataPath, DataContext context) throws SAXException, BadItemTypeException, UndefinedItemPathException
    {
        _task.dataToSAX(contentHandler, dataPath, context);
    }

    public Object dataToJSON(String dataPath, DataContext context) throws BadItemTypeException, UndefinedItemPathException
    {
        return _task.dataToJSON(dataPath, context);
    }

    public RepositoryData getRepositoryData()
    {
        return _task.getRepositoryData();
    }

    public List<SolrInputDocument> indexData(SolrInputDocument document, CMSDataContext context) throws BadItemTypeException
    {
        return _task.indexData(document, context);
    }

    public Collection< ? extends Model> getModel()
    {
        return _task.getModel();
    }

    public boolean hasValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _task.hasValue(dataPath);
    }

    public boolean hasLocalValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _task.hasLocalValue(dataPath);
    }

    public boolean hasExternalValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _task.hasExternalValue(dataPath);
    }
    
    public boolean hasValue(String dataPath, String dataTypeId) throws IllegalArgumentException, UnknownTypeException, BadDataPathCardinalityException
    {
        return _task.hasValue(dataPath, dataTypeId);
    }

    public boolean hasValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _task.hasValueOrEmpty(dataPath);
    }

    public boolean hasLocalValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _task.hasLocalValueOrEmpty(dataPath);
    }

    public boolean hasExternalValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return _task.hasExternalValueOrEmpty(dataPath);
    }

    public Collection<String> getDataNames()
    {
        return _task.getDataNames();
    }
    
    public <T> T getValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getValue(dataPath);
    }

    public <T> T getLocalValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getLocalValue(dataPath);
    }

    public <T> T getExternalValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getExternalValue(dataPath);
    }

    public <T> T getValueOrDefault(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getValueOrDefault(dataPath);
    }
    
    public <T> T getValueOrDefault(String dataPath, T defaultValue) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getValueOrDefault(dataPath, defaultValue);
    }
    
    public <T> T getValueOfType(String dataPath, String dataTypeId) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getValueOfType(dataPath, dataTypeId);
    }
    
    public <T> T getValueOfTypeOrDefault(String dataPath, String dataTypeId, T defaultValue) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getValueOfTypeOrDefault(dataPath, dataTypeId, defaultValue);
    }

    public <T> T getValueWithMultiValuedPathSegments(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getValueWithMultiValuedPathSegments(dataPath);
    }

    public ExternalizableDataStatus getStatus(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getStatus(dataPath);
    }
    
    public boolean isMultiple(String dataPath) throws IllegalArgumentException, UndefinedItemPathException
    {
        return _task.isMultiple(dataPath);
    }
    
    public boolean isMultiple(String dataPath, String dataTypeId) throws IllegalArgumentException, UndefinedItemPathException
    {
        return _task.isMultiple(dataPath, dataTypeId);
    }
    
    public <X extends ModelItemType> X getType(String dataPath) throws IllegalArgumentException, UndefinedItemPathException
    {
        return _task.getType(dataPath);
    }
    
    public void copyTo(ModifiableDataHolder dataHolder) throws BadItemTypeException, UndefinedItemPathException
    {
        _task.copyTo(dataHolder);
    }
    
    public void copyTo(ModifiableDataHolder dataHolder, DataContext context) throws BadItemTypeException, UndefinedItemPathException
    {
        _task.copyTo(dataHolder, context);
    }

    public void dataToSAX(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException
    {
        _task.dataToSAX(contentHandler, viewItemAccessor, context);
    }

    public void dataToSAXForEdition(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException
    {
        _task.dataToSAXForEdition(contentHandler, viewItemAccessor, context);
    }

    public Map<String, Object> dataToJSON(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        return _task.dataToJSON(viewItemAccessor, context);
    }

    public Map<String, Object> dataToJSONForEdition(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        return _task.dataToJSONForEdition(viewItemAccessor, context);
    }

    public Map<String, Object> dataToMap(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        return _task.dataToMap(viewItemAccessor, context);
    }

    public boolean hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws BadItemTypeException
    {
        return _task.hasDifferences(viewItemAccessor, values);
    }

    public boolean hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException
    {
        return _task.hasDifferences(viewItemAccessor, values, context);
    }

    public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws BadItemTypeException
    {
        return _task.getDifferences(viewItemAccessor, values);
    }

    public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException
    {
        return _task.getDifferences(viewItemAccessor, values, context);
    }

    public IndexableComposite getComposite(String compositePath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getComposite(compositePath);
    }

    public IndexableComposite getLocalComposite(String compositePath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getLocalComposite(compositePath);
    }

    public IndexableComposite getExternalComposite(String compositePath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getExternalComposite(compositePath);
    }

    public IndexableRepeater getRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getRepeater(repeaterPath);
    }

    public IndexableRepeater getLocalRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getLocalRepeater(repeaterPath);
    }

    public IndexableRepeater getExternalRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return _task.getExternalRepeater(repeaterPath);
    }

    public Optional< ? extends IndexableDataHolder> getParentDataHolder()
    {
        return _task.getParentDataHolder();
    }

    public IndexableDataHolder getRootDataHolder()
    {
        return _task.getRootDataHolder();
    }
}