PVRTimers.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 "pvr/settings/PVRSettings.h"
#include "threads/Thread.h"

#include <map>
#include <memory>
#include <queue>
#include <vector>

class CDateTime;

namespace PVR
{
enum class TimerOperationResult;
enum class PVREvent;

class CPVRChannel;
class CPVRClient;
class CPVREpgInfoTag;
class CPVRTimerInfoTag;
class CPVRTimersPath;

class CPVRTimersContainer
{
public:
  bool UpdateFromClient(const std::shared_ptr<CPVRTimerInfoTag>& timer);

  std::shared_ptr<CPVRTimerInfoTag> GetByClient(int iClientId, int iClientIndex) const;

  typedef std::vector<std::shared_ptr<CPVRTimerInfoTag>> VecTimerInfoTag;
  typedef std::map<CDateTime, VecTimerInfoTag> MapTags;

  const MapTags& GetTags() const { return m_tags; }

protected:
  void InsertEntry(const std::shared_ptr<CPVRTimerInfoTag>& newTimer);

  mutable CCriticalSection m_critSection;
  unsigned int m_iLastId = 0;
  MapTags m_tags;
};

class CPVRTimers : public CPVRTimersContainer, private CThread
{
public:
  CPVRTimers();
  ~CPVRTimers() override = default;

  void Start();

  void Stop();

  bool Update(const std::vector<std::shared_ptr<CPVRClient>>& clients);

  void Unload();

  bool UpdateFromClients(const std::vector<std::shared_ptr<CPVRClient>>& clients);

  std::shared_ptr<CPVRTimerInfoTag> GetNextActiveTimer(bool bIgnoreReminders = true) const;

  std::shared_ptr<CPVRTimerInfoTag> GetNextActiveTVTimer() const;

  std::shared_ptr<CPVRTimerInfoTag> GetNextActiveRadioTimer() const;

  std::vector<std::shared_ptr<CPVRTimerInfoTag>> GetActiveTimers() const;

  std::shared_ptr<CPVRTimerInfoTag> GetNextReminderToAnnnounce();

  std::vector<std::shared_ptr<CPVRTimerInfoTag>> GetAll() const;

  int AmountActiveTimers() const;

  int AmountActiveTVTimers() const;

  int AmountActiveRadioTimers() const;

  std::vector<std::shared_ptr<CPVRTimerInfoTag>> GetActiveRecordings() const;

  std::vector<std::shared_ptr<CPVRTimerInfoTag>> GetActiveTVRecordings() const;

  std::vector<std::shared_ptr<CPVRTimerInfoTag>> GetActiveRadioRecordings() const;

  bool IsRecording() const;

  bool IsRecordingOnChannel(const CPVRChannel& channel) const;

  std::shared_ptr<CPVRTimerInfoTag> GetActiveTimerForChannel(
      const std::shared_ptr<CPVRChannel>& channel) const;

  int AmountActiveRecordings() const;

  int AmountActiveTVRecordings() const;

  int AmountActiveRadioRecordings() const;

  bool DeleteTimersOnChannel(const std::shared_ptr<CPVRChannel>& channel,
                             bool bDeleteTimerRules = true,
                             bool bCurrentlyActiveOnly = false);

  CDateTime GetNextEventTime() const;

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

  TimerOperationResult DeleteTimer(const std::shared_ptr<CPVRTimerInfoTag>& tag,
                                   bool bForce = false,
                                   bool bDeleteRule = false);

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

  std::shared_ptr<CPVRTimerInfoTag> GetTimerForEpgTag(
      const std::shared_ptr<CPVREpgInfoTag>& epgTag) const;

  std::shared_ptr<CPVRTimerInfoTag> GetTimerRule(
      const std::shared_ptr<CPVRTimerInfoTag>& timer) const;

  void UpdateChannels();

  void Notify(const PVREvent& event);

  std::shared_ptr<CPVRTimerInfoTag> GetById(unsigned int iTimerId) const;

private:
  void Process() override;

  bool LoadFromDatabase(const std::vector<std::shared_ptr<CPVRClient>>& clients);

  void RemoveEntry(const std::shared_ptr<CPVRTimerInfoTag>& tag);
  bool UpdateEntries(const CPVRTimersContainer& timers, const std::vector<int>& failedClients);
  bool UpdateEntries(int iMaxNotificationDelay);
  std::shared_ptr<CPVRTimerInfoTag> UpdateEntry(const std::shared_ptr<CPVRTimerInfoTag>& timer);

  bool AddLocalTimer(const std::shared_ptr<CPVRTimerInfoTag>& tag, bool bNotify);
  bool DeleteLocalTimer(const std::shared_ptr<CPVRTimerInfoTag>& tag, bool bNotify);
  bool UpdateLocalTimer(const std::shared_ptr<CPVRTimerInfoTag>& tag);
  std::shared_ptr<CPVRTimerInfoTag> PersistAndUpdateLocalTimer(
      const std::shared_ptr<CPVRTimerInfoTag>& timer,
      const std::shared_ptr<CPVRTimerInfoTag>& parentTimer);
  void NotifyTimersEvent(bool bAddedOrDeleted = true);

  enum TimerKind
  {
    TimerKindAny = 0,
    TimerKindTV,
    TimerKindRadio
  };

  bool KindMatchesTag(const TimerKind& eKind, const std::shared_ptr<CPVRTimerInfoTag>& tag) const;

  std::shared_ptr<CPVRTimerInfoTag> GetNextActiveTimer(const TimerKind& eKind,
                                                       bool bIgnoreReminders) const;
  int AmountActiveTimers(const TimerKind& eKind) const;
  std::vector<std::shared_ptr<CPVRTimerInfoTag>> GetActiveRecordings(const TimerKind& eKind) const;
  int AmountActiveRecordings(const TimerKind& eKind) const;

  bool CheckAndAppendTimerNotification(std::vector<std::pair<int, std::string>>& timerNotifications,
                                       const std::shared_ptr<CPVRTimerInfoTag>& tag,
                                       bool bDeleted) const;

  bool m_bIsUpdating = false;
  CPVRSettings m_settings;
  std::queue<std::shared_ptr<CPVRTimerInfoTag>> m_remindersToAnnounce;
  bool m_bReminderRulesUpdatePending = false;

  bool m_bFirstUpdate = true;
  std::vector<int> m_failedClients;
};
} // namespace PVR