PVRChannelGroup.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/channels/PVRChannelGroupSettings.h"
#include "pvr/channels/PVRChannelNumber.h"
#include "pvr/channels/PVRChannelsPath.h"
#include "utils/EventStream.h"

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

struct PVR_CHANNEL_GROUP;

namespace PVR
{
static constexpr int PVR_GROUP_TYPE_REMOTE = 0;
static constexpr int PVR_GROUP_TYPE_ALL_CHANNELS = 1;
static constexpr int PVR_GROUP_TYPE_LOCAL = 2;

static constexpr int PVR_GROUP_CLIENT_ID_UNKNOWN = -2;
static constexpr int PVR_GROUP_CLIENT_ID_LOCAL = -1;

static constexpr int PVR_GROUP_ID_UNNKOWN{-1};

enum class PVREvent;

class CPVRChannel;
class CPVRChannelGroupMember;
class CPVRClient;
class CPVREpgInfoTag;

enum RenumberMode
{
  NORMAL = 0,
  IGNORE_NUMBERING_FROM_ONE = 1
};

using GroupMemberPair =
    std::pair<std::shared_ptr<CPVRChannelGroupMember>, std::shared_ptr<CPVRChannelGroupMember>>;

class CPVRChannelGroup : public IChannelGroupSettingsCallback
{
  friend class CPVRChannelGroups; // for GroupType()
  friend class CPVRDatabase; // for GroupType()

public:
  static const int INVALID_GROUP_ID = -1;

  CPVRChannelGroup(const CPVRChannelsPath& path,
                   const std::shared_ptr<CPVRChannelGroup>& allChannelsGroup);

  ~CPVRChannelGroup() override;

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

  void FillAddonData(PVR_CHANNEL_GROUP& group) const;

  CEventStream<PVREvent>& Events() { return m_events; }

  bool LoadFromDatabase(const std::map<std::pair<int, int>, std::shared_ptr<CPVRChannel>>& channels,
                        const std::vector<std::shared_ptr<CPVRClient>>& clients);

  void Unload();

  size_t Size() const;

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

  int GetClientID() const;

  void SetClientID(int clientID);

  const CPVRChannelsPath& GetPath() const;

  void SetPath(const CPVRChannelsPath& path);

  virtual bool RemoveFromGroup(const std::shared_ptr<CPVRChannelGroupMember>& groupMember);

  virtual bool AppendToGroup(const std::shared_ptr<CPVRChannelGroupMember>& groupMember);

  virtual bool IsGroupMember(const std::shared_ptr<CPVRChannelGroupMember>& groupMember) const;

  void SetGroupName(const std::string& strGroupName, bool isUserSetName = false);

  void SetClientGroupName(const std::string& groupName);

  bool IsUserSetName() const { return m_isUserSetName; }

  bool Persist();

  bool IsRadio() const;

  int GroupID() const;

  void SetGroupID(int iGroupId);

  time_t LastWatched() const;

  void SetLastWatched(time_t iLastWatched);

  uint64_t LastOpened() const;

  void SetLastOpened(uint64_t iLastOpened);

  std::string GroupName() const;

  std::string ClientGroupName() const;


  void Sort();

  bool SortAndRenumber();

  bool Renumber(RenumberMode mode = NORMAL);


  // IChannelGroupSettingsCallback implementation
  void UseBackendChannelOrderChanged() override;
  void UseBackendChannelNumbersChanged() override;
  void StartGroupChannelNumbersFromOneChanged() override;

  std::shared_ptr<CPVRChannelGroupMember> GetLastPlayedChannelGroupMember(
      int iCurrentChannel = -1) const;

  GroupMemberPair GetLastAndPreviousToLastPlayedChannelGroupMember() const;

  std::shared_ptr<CPVRChannelGroupMember> GetByChannelNumber(
      const CPVRChannelNumber& channelNumber) const;

  CPVRChannelNumber GetChannelNumber(const std::shared_ptr<CPVRChannel>& channel) const;

  CPVRChannelNumber GetClientChannelNumber(const std::shared_ptr<CPVRChannel>& channel) const;

  std::shared_ptr<CPVRChannelGroupMember> GetNextChannelGroupMember(
      const std::shared_ptr<CPVRChannelGroupMember>& groupMember) const;

  std::shared_ptr<CPVRChannelGroupMember> GetPreviousChannelGroupMember(
      const std::shared_ptr<CPVRChannelGroupMember>& groupMember) const;

  std::shared_ptr<CPVRChannel> GetByChannelID(int iChannelID) const;

  enum class Include
  {
    ALL,
    ONLY_HIDDEN,
    ONLY_VISIBLE
  };

  std::vector<std::shared_ptr<CPVRChannelGroupMember>> GetMembers(
      Include eFilter = Include::ALL) const;

  void GetChannelNumbers(std::vector<std::string>& channelNumbers) const;

  bool HasChannels() const;

  bool HasNewChannels() const;

  bool HasHiddenChannels() const;

  bool HasChanges() const;

  bool IsNew() const;

  std::shared_ptr<CPVRChannel> GetByUniqueID(int iUniqueChannelId, int iClientID) const;

  std::shared_ptr<CPVRChannelGroupMember> GetByUniqueID(const std::pair<int, int>& id) const;

  bool SetHidden(bool bHidden);
  bool IsHidden() const;

  int GetPosition() const;

  void SetPosition(int iPosition);

  int GetClientPosition() const;

  void SetClientPosition(int iPosition);

  bool HasValidDataForClient(int iClientId) const;

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

  bool UpdateChannelNumbersFromAllChannelsGroup();

  void Delete();

  bool IsDeleted() const { return m_bDeleted; }

  int CleanupCachedImages();

  int GetClientPriority() const;

  void UpdateClientPriorities();

  virtual bool SupportsDelete() const = 0;

  virtual bool SupportsMemberAdd() const = 0;

  virtual bool SupportsMemberRemove() const = 0;

  virtual bool IsChannelsOwner() const = 0;

protected:
  virtual std::vector<std::shared_ptr<CPVRChannelGroupMember>> RemoveDeletedGroupMembers(
      const std::vector<std::shared_ptr<CPVRChannelGroupMember>>& groupMembers);

  bool UpdateGroupEntries(const std::vector<std::shared_ptr<CPVRChannelGroupMember>>& groupMembers);

  void SortByClientChannelNumber();

  void SortByChannelNumber();

  bool UpdateMembersClientPriority();

  std::shared_ptr<CPVRChannelGroupSettings> GetSettings() const;

  int m_iGroupId = INVALID_GROUP_ID; 
  bool m_bLoaded = false; 
  bool m_bChanged =
      false; 
  time_t m_iLastWatched = 0; 
  uint64_t m_iLastOpened = 0; 
  bool m_bHidden = false; 
  int m_iPosition = 0; 
  std::vector<std::shared_ptr<CPVRChannelGroupMember>>
      m_sortedMembers; 
  std::map<std::pair<int, int>, std::shared_ptr<CPVRChannelGroupMember>>
      m_members; 
  mutable CCriticalSection m_critSection;
  std::vector<int> m_failedClients;
  CEventSource<PVREvent> m_events;
  mutable std::shared_ptr<CPVRChannelGroupSettings> m_settings;

  // the settings singleton shared between all group instances
  static CCriticalSection m_settingsSingletonCritSection;
  static std::weak_ptr<CPVRChannelGroupSettings> m_settingsSingleton;

private:
  virtual int GroupType() const = 0;

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

  void DeleteGroupMembersFromDb(
      const std::vector<std::shared_ptr<CPVRChannelGroupMember>>& membersToDelete);

  bool UpdateFromClient(const std::shared_ptr<CPVRChannelGroupMember>& groupMember);

  bool AddAndUpdateGroupMembers(
      const std::vector<std::shared_ptr<CPVRChannelGroupMember>>& groupMembers);

  void OnSettingChanged();

  std::shared_ptr<CPVRChannelGroup> m_allChannelsGroup;
  CPVRChannelsPath m_path;
  bool m_bDeleted = false;
  mutable std::optional<int> m_clientPriority;
  bool m_isUserSetName{false};
  std::string m_clientGroupName;
  int m_iClientPosition{0};
};
} // namespace PVR