PVRTimerInfoTag.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 "XBDateTime.h"
#include "pvr/timers/PVRTimerType.h"
#include "threads/CriticalSection.h"
#include "utils/ISerializable.h"

#include <memory>
#include <string>

struct PVR_TIMER;

namespace PVR
{
class CPVRChannel;
class CPVREpgInfoTag;

enum class TimerOperationResult
{
  OK = 0,
  FAILED,
  RECORDING // The timer was not deleted because it is currently recording (see DeleteTimer).
};

class CPVRTimerInfoTag final : public ISerializable
{
  // allow these classes direct access to members as they act as timer tag instance factories.
  friend class CGUIDialogPVRTimerSettings;
  friend class CPVRDatabase;

public:
  explicit CPVRTimerInfoTag(bool bRadio = false);
  CPVRTimerInfoTag(const PVR_TIMER& timer,
                   const std::shared_ptr<CPVRChannel>& channel,
                   unsigned int iClientId);

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

  void FillAddonData(PVR_TIMER& timer) const;

  // ISerializable implementation
  void Serialize(CVariant& value) const override;

  static constexpr int DEFAULT_PVRRECORD_INSTANTRECORDTIME = -1;

  static std::shared_ptr<CPVRTimerInfoTag> CreateInstantTimerTag(
      const std::shared_ptr<CPVRChannel>& channel,
      int iDuration = DEFAULT_PVRRECORD_INSTANTRECORDTIME);

  static std::shared_ptr<CPVRTimerInfoTag> CreateTimerTag(
      const std::shared_ptr<CPVRChannel>& channel, const CDateTime& start, int iDuration);

  static std::shared_ptr<CPVRTimerInfoTag> CreateFromEpg(const std::shared_ptr<CPVREpgInfoTag>& tag,
                                                         bool bCreateRule,
                                                         bool bCreateReminder,
                                                         bool bReadOnly = false);

  static std::shared_ptr<CPVRTimerInfoTag> CreateFromEpg(const std::shared_ptr<CPVREpgInfoTag>& tag,
                                                         bool bCreateRule = false);

  static std::shared_ptr<CPVRTimerInfoTag> CreateReminderFromDate(
      const CDateTime& start,
      int iDuration,
      const std::shared_ptr<CPVRTimerInfoTag>& parent = std::shared_ptr<CPVRTimerInfoTag>());

  static std::shared_ptr<CPVRTimerInfoTag> CreateReminderFromEpg(
      const std::shared_ptr<CPVREpgInfoTag>& tag,
      const std::shared_ptr<CPVRTimerInfoTag>& parent = std::shared_ptr<CPVRTimerInfoTag>());

  void SetEpgInfoTag(const std::shared_ptr<CPVREpgInfoTag>& tag);

  std::shared_ptr<CPVREpgInfoTag> GetEpgInfoTag(bool bCreate = true) const;

  bool UpdateEntry(const std::shared_ptr<const CPVRTimerInfoTag>& tag);

  bool UpdateChildState(const std::shared_ptr<const CPVRTimerInfoTag>& childTimer, bool bAdd);

  void ResetChildState();

  bool IsActive() const
  {
    return m_state == PVR_TIMER_STATE_SCHEDULED || m_state == PVR_TIMER_STATE_RECORDING ||
           m_state == PVR_TIMER_STATE_CONFLICT_OK || m_state == PVR_TIMER_STATE_CONFLICT_NOK ||
           m_state == PVR_TIMER_STATE_ERROR;
  }

  bool IsBroken() const
  {
    return m_state == PVR_TIMER_STATE_CONFLICT_NOK || m_state == PVR_TIMER_STATE_ERROR;
  }

  bool HasConflict() const { return m_state == PVR_TIMER_STATE_CONFLICT_NOK; }

  bool IsRecording() const { return m_state == PVR_TIMER_STATE_RECORDING; }

  bool IsDisabled() const { return m_state == PVR_TIMER_STATE_DISABLED; }

  const std::shared_ptr<CPVRTimerType> GetTimerType() const { return m_timerType; }

  void SetTimerType(const std::shared_ptr<CPVRTimerType>& type);

  bool IsTimerRule() const { return m_timerType && m_timerType->IsTimerRule(); }

  bool IsReminder() const { return m_timerType && m_timerType->IsReminder(); }

  bool IsManual() const { return m_timerType && m_timerType->IsManual(); }

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

  int ClientID() const { return m_iClientId; }

  bool IsOwnedByClient() const;

  bool IsRadio() const { return m_bIsRadio; }

  const std::string& Path() const;

  int ClientIndex() const { return m_iClientIndex; }

  int ParentClientIndex() const { return m_iParentClientIndex; }

  bool HasParent() const { return m_iParentClientIndex != PVR_TIMER_NO_PARENT; }

  unsigned int TimerID() const { return m_iTimerId; }

  void SetTimerID(unsigned int id) { m_iTimerId = id; }

  int ClientChannelUID() const { return m_iClientChannelUid; }

  PVR_TIMER_STATE State() const { return m_state; }

  void SetState(PVR_TIMER_STATE state) { m_state = state; }

  const std::string& Title() const;

  bool HasChannel() const;

  std::shared_ptr<CPVRChannel> Channel() const;

  void UpdateChannel();

  std::string ChannelName() const;

  std::string ChannelIcon() const;

  CDateTime StartAsUTC() const;

  CDateTime StartAsLocalTime() const;

  void SetStartFromUTC(const CDateTime& start);

  void SetStartFromLocalTime(const CDateTime& start);

  CDateTime EndAsUTC() const;

  CDateTime EndAsLocalTime() const;

  void SetEndFromUTC(const CDateTime& end);

  void SetEndFromLocalTime(const CDateTime& end);

  CDateTime FirstDayAsUTC() const;

  CDateTime FirstDayAsLocalTime() const;

  void SetFirstDayFromUTC(const CDateTime& firstDay);

  void SetFirstDayFromLocalTime(const CDateTime& firstDay);

  static CDateTime ConvertUTCToLocalTime(const CDateTime& utc);

  static CDateTime ConvertLocalTimeToUTC(const CDateTime& local);

  int GetDuration() const;

  unsigned int MarginStart() const { return m_iMarginStart; }

  unsigned int MarginEnd() const { return m_iMarginEnd; }

  unsigned int WeekDays() const { return m_iWeekdays; }

  bool IsStartAnyTime() const { return m_bStartAnyTime; }

  bool IsEndAnyTime() const { return m_bEndAnyTime; }

  bool IsFullTextEpgSearch() const { return m_bFullTextEpgSearch; }

  const std::string& EpgSearchString() const { return m_strEpgSearchString; }

  const std::string& SeriesLink() const;

  unsigned int UniqueBroadcastID() const { return m_iEpgUid; }

  bool AddToClient() const;

  TimerOperationResult DeleteFromClient(bool bForce = false) const;

  bool UpdateOnClient();

  bool Persist();

  bool DeleteFromDatabase();

  std::string GetNotificationText() const;

  std::string GetDeletedNotificationText() const;

  const std::string& Summary() const;

  void UpdateSummary();

  std::string GetStatus(bool bRadio) const;

  std::string GetTypeAsString() const;

  static std::string GetWeekdaysString(unsigned int iWeekdays,
                                       bool bEpgBased,
                                       bool bLongMultiDaysFormat);

private:
  CPVRTimerInfoTag(const CPVRTimerInfoTag& tag) = delete;
  CPVRTimerInfoTag& operator=(const CPVRTimerInfoTag& orig) = delete;

  std::string GetWeekdaysString() const;
  void UpdateEpgInfoTag();

  static std::shared_ptr<CPVRTimerInfoTag> CreateFromDate(
      const std::shared_ptr<CPVRChannel>& channel,
      const CDateTime& start,
      int iDuration,
      bool bCreateReminder,
      bool bReadOnly);

  mutable CCriticalSection m_critSection;

  std::string m_strTitle; 
  std::string
      m_strEpgSearchString; 
  bool m_bFullTextEpgSearch =
      false; 
  std::string m_strDirectory; 
  std::string m_strSummary; 
  PVR_TIMER_STATE m_state = PVR_TIMER_STATE_SCHEDULED; 
  int m_iClientId; 
  int m_iClientIndex; 
  int m_iParentClientIndex; 
  int m_iClientChannelUid; 
  bool m_bStartAnyTime =
      false; 
  bool m_bEndAnyTime = false; 
  int m_iPriority; 
  int m_iLifetime; 
  int m_iMaxRecordings =
      0; 
  unsigned int m_iWeekdays; 
  unsigned int
      m_iPreventDupEpisodes; 
  unsigned int m_iRecordingGroup =
      0; 
  std::string m_strFileNameAndPath; 
  bool m_bIsRadio; 
  unsigned int m_iTimerId = 0; 
  unsigned int
      m_iMarginStart; 
  unsigned int
      m_iMarginEnd; 
  mutable unsigned int
      m_iEpgUid; 
  std::string m_strSeriesLink; 
  CDateTime m_StartTime; 
  CDateTime m_StopTime; 
  CDateTime m_FirstDay; 
  std::shared_ptr<CPVRTimerType> m_timerType; 
  unsigned int m_iTVChildTimersActive = 0;
  unsigned int m_iTVChildTimersConflictNOK = 0;
  unsigned int m_iTVChildTimersRecording = 0;
  unsigned int m_iTVChildTimersErrors = 0;
  unsigned int m_iRadioChildTimersActive = 0;
  unsigned int m_iRadioChildTimersConflictNOK = 0;
  unsigned int m_iRadioChildTimersRecording = 0;
  unsigned int m_iRadioChildTimersErrors = 0;

  mutable std::shared_ptr<CPVREpgInfoTag> m_epgTag; 
  mutable std::shared_ptr<CPVRChannel> m_channel;

  mutable bool m_bProbedEpgTag = false;
};
} // namespace PVR