PVRTimerType.h

/*
 *  Copyright (C) 2012-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr/pvr_timers.h"

#include <memory>
#include <string>
#include <utility>
#include <vector>

struct PVR_TIMER_TYPE;

namespace PVR
{
  class CPVRClient;

  static const int DEFAULT_RECORDING_PRIORITY = 50;
  static const int DEFAULT_RECORDING_LIFETIME = 99; // days
  static const unsigned int DEFAULT_RECORDING_DUPLICATEHANDLING = 0;

  class CPVRTimerType
  {
  public:
    static const std::vector<std::shared_ptr<CPVRTimerType>> GetAllTypes();

    static const std::shared_ptr<CPVRTimerType> GetFirstAvailableType(const std::shared_ptr<CPVRClient>& client);

    static std::shared_ptr<CPVRTimerType> CreateFromIds(unsigned int iTypeId, int iClientId);

    static std::shared_ptr<CPVRTimerType> CreateFromAttributes(uint64_t iMustHaveAttr,
                                                               uint64_t iMustNotHaveAttr,
                                                               int iClientId);

    CPVRTimerType();
    CPVRTimerType(const PVR_TIMER_TYPE& type, int iClientId);
    CPVRTimerType(unsigned int iTypeId,
                  uint64_t iAttributes,
                  const std::string& strDescription = "");

    virtual ~CPVRTimerType();

    CPVRTimerType(const CPVRTimerType& type) = delete;
    CPVRTimerType& operator=(const CPVRTimerType& orig) = delete;

    bool operator ==(const CPVRTimerType& right) const;
    bool operator !=(const CPVRTimerType& right) const;

    void Update(const CPVRTimerType& type);

    int GetClientId() const { return m_iClientId; }

    unsigned int GetTypeId() const { return m_iTypeId; }

    const std::string& GetDescription() const { return m_strDescription; }

    uint64_t GetAttributes() const { return m_iAttributes; }

    bool IsTimerRule() const { return (m_iAttributes & PVR_TIMER_TYPE_IS_REPEATING) > 0; }

    bool IsReminder() const { return (m_iAttributes & PVR_TIMER_TYPE_IS_REMINDER) > 0; }

    bool IsOnetime() const { return !IsTimerRule(); }

    bool IsManual() const { return (m_iAttributes & PVR_TIMER_TYPE_IS_MANUAL) > 0; }

    bool IsEpgBased() const { return !IsManual(); }

    bool IsEpgBasedTimerRule() const { return IsEpgBased() && IsTimerRule(); }

    bool IsEpgBasedOnetime() const { return IsEpgBased() && IsOnetime(); }

    bool IsManualTimerRule() const { return IsManual() && IsTimerRule(); }

    bool IsManualOnetime() const { return IsManual() && IsOnetime(); }

    bool IsReadOnly() const { return (m_iAttributes & PVR_TIMER_TYPE_IS_READONLY) > 0; }

    bool AllowsDelete() const { return !IsReadOnly() || SupportsReadOnlyDelete(); }

    bool ForbidsNewInstances() const { return (m_iAttributes & PVR_TIMER_TYPE_FORBIDS_NEW_INSTANCES) > 0; }

    bool ForbidsEpgTagOnCreate() const { return (m_iAttributes & PVR_TIMER_TYPE_FORBIDS_EPG_TAG_ON_CREATE) > 0; }

    bool RequiresEpgTagOnCreate() const { return (m_iAttributes & (PVR_TIMER_TYPE_REQUIRES_EPG_TAG_ON_CREATE |
                                                                   PVR_TIMER_TYPE_REQUIRES_EPG_SERIES_ON_CREATE |
                                                                   PVR_TIMER_TYPE_REQUIRES_EPG_SERIESLINK_ON_CREATE)) > 0; }

    bool RequiresEpgSeriesOnCreate() const { return (m_iAttributes & PVR_TIMER_TYPE_REQUIRES_EPG_SERIES_ON_CREATE) > 0; }

    bool RequiresEpgSeriesLinkOnCreate() const { return (m_iAttributes & PVR_TIMER_TYPE_REQUIRES_EPG_SERIESLINK_ON_CREATE) > 0; }

    bool SupportsEnableDisable() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_ENABLE_DISABLE) > 0; }

    bool SupportsChannels() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_CHANNELS) > 0; }

    bool SupportsStartTime() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_START_TIME) > 0; }

    bool SupportsEndTime() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_END_TIME) > 0; }
    bool SupportsStartAnyTime() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_START_ANYTIME) > 0; }

    bool SupportsEndAnyTime() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_END_ANYTIME) > 0; }

    bool SupportsEpgTitleMatch() const { return (m_iAttributes & (PVR_TIMER_TYPE_SUPPORTS_TITLE_EPG_MATCH | PVR_TIMER_TYPE_SUPPORTS_FULLTEXT_EPG_MATCH)) > 0; }

    bool SupportsEpgFulltextMatch() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_FULLTEXT_EPG_MATCH) > 0; }

    bool SupportsFirstDay() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_FIRST_DAY) > 0; }

    bool SupportsWeekdays() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_WEEKDAYS) > 0; }

    bool SupportsRecordOnlyNewEpisodes() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_RECORD_ONLY_NEW_EPISODES) > 0; }

    bool SupportsStartMargin() const
    {
      return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_START_MARGIN) > 0 ||
             (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_START_END_MARGIN) > 0;
    }

    bool SupportsEndMargin() const
    {
      return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_END_MARGIN) > 0 ||
             (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_START_END_MARGIN) > 0;
    }

    bool SupportsPriority() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_PRIORITY) > 0; }

    bool SupportsLifetime() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_LIFETIME) > 0; }

    bool SupportsMaxRecordings() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_MAX_RECORDINGS) > 0; }

    bool SupportsRecordingFolders() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_RECORDING_FOLDERS) > 0; }

    bool SupportsRecordingGroup() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_RECORDING_GROUP) > 0; }

    bool SupportsAnyChannel() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_ANY_CHANNEL) > 0; }

    bool SupportsReadOnlyDelete() const { return (m_iAttributes & PVR_TIMER_TYPE_SUPPORTS_READONLY_DELETE) > 0; }

    void GetPriorityValues(std::vector<std::pair<std::string, int>>& list) const;

    int GetPriorityDefault() const { return m_iPriorityDefault; }

    void GetLifetimeValues(std::vector<std::pair<std::string, int>>& list) const;

    int GetLifetimeDefault() const { return m_iLifetimeDefault; }

    void GetMaxRecordingsValues(std::vector<std::pair<std::string, int>>& list) const;

    int GetMaxRecordingsDefault() const { return m_iMaxRecordingsDefault; }

    void GetPreventDuplicateEpisodesValues(std::vector<std::pair<std::string, int>>& list) const;

    int GetPreventDuplicateEpisodesDefault() const { return m_iPreventDupEpisodesDefault; }

    void GetRecordingGroupValues(std::vector<std::pair<std::string, int>>& list) const;

    int GetRecordingGroupDefault() const { return m_iRecordingGroupDefault; }

  private:
    void InitDescription();
    void InitAttributeValues(const PVR_TIMER_TYPE& type);
    void InitPriorityValues(const PVR_TIMER_TYPE& type);
    void InitLifetimeValues(const PVR_TIMER_TYPE& type);
    void InitMaxRecordingsValues(const PVR_TIMER_TYPE& type);
    void InitPreventDuplicateEpisodesValues(const PVR_TIMER_TYPE& type);
    void InitRecordingGroupValues(const PVR_TIMER_TYPE& type);

    int m_iClientId = -1;
    unsigned int m_iTypeId;
    uint64_t m_iAttributes;
    std::string m_strDescription;
    std::vector< std::pair<std::string, int> > m_priorityValues;
    int m_iPriorityDefault = DEFAULT_RECORDING_PRIORITY;
    std::vector< std::pair<std::string, int> > m_lifetimeValues;
    int m_iLifetimeDefault = DEFAULT_RECORDING_LIFETIME;
    std::vector< std::pair<std::string, int> > m_maxRecordingsValues;
    int m_iMaxRecordingsDefault = 0;
    std::vector< std::pair<std::string, int> > m_preventDupEpisodesValues;
    unsigned int m_iPreventDupEpisodesDefault = DEFAULT_RECORDING_DUPLICATEHANDLING;
    std::vector< std::pair<std::string, int> > m_recordingGroupValues;
    unsigned int m_iRecordingGroupDefault = 0;
  };
}