///////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
// All rights reserved.
//
// This software and its documentation and related materials are owned by
// the Alliance. The software may only be incorporated into application
// programs owned by members of the Alliance, subject to a signed
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable
// trade secrets of the Alliance and its suppliers. The software is also
// protected by copyright law and international treaty provisions. Application
// programs incorporating this software must include the following statement
// with their copyright notices:
//
//   This application incorporates Open Design Alliance software pursuant to a license
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////
#ifndef TV_STREAMING_CLIENT_H
#define TV_STREAMING_CLIENT_H

#include <memory>
#include <mutex>
#include "OdVector.h"
#include <list>
#include <map>

#include "TvMessage.h"

struct OdTvStreamingClientData
{
  enum class Type
  {
    kBinData,
    kStringList
  };
  enum class Status
  {
    kInProgress,
    kError,
    kComplete
  };
  virtual Type type() const = 0;
  virtual Status status() const = 0;
};
typedef std::shared_ptr< OdTvStreamingClientData > OdTvStreamingClientDataPtr;

struct OdTvStreamingClientBinaryData : public OdTvStreamingClientData
{
  virtual OdTvStreamingClientData::Type type() const override { return OdTvStreamingClientData::Type::kBinData; }
  virtual OdTvStreamingClientData::Status status() const override { return currentStatus; }
  OdVector< char > buffer;
  OdTvStreamingClientData::Status currentStatus = OdTvStreamingClientData::Status::kInProgress;

  void set( const char* pData, unsigned sz )
  {
    buffer.resize( sz );
    memcpy( buffer.asArrayPtr(), pData, sz );
  }
  void add( const char* pData, unsigned sz )
  {
    unsigned extistDataSz = buffer.size();
    buffer.resize( extistDataSz + sz );
    memcpy( buffer.asArrayPtr() + extistDataSz, pData, sz );
  }
};

struct OdTvStreamingClientStringListData : public OdTvStreamingClientData
{
  OdVector< OdString > stringList;
  virtual OdTvStreamingClientData::Type type() const override { return OdTvStreamingClientData::Type::kStringList; }
  virtual OdTvStreamingClientData::Status status() const override { return OdTvStreamingClientData::Status::kComplete; }
};

class OdTvStreamingClient : public OdTvMessageBuilder::OdTvMessageBuilderReactor
{
public:
  enum class Status
  {
    kOk = 0,
    kNotConnected = 1,
    kError = 2
  };

  static std::shared_ptr< OdTvStreamingClient > createClient();
  bool startClient( const char* ip, const char* port );

  OdUInt64 requestFileList( bool bPartialOnly );
  OdUInt64 requestFile( const OdString& file );
  OdUInt64 requestFileParts( const OdString& file, const OdVector< OdTvMessage::FilePart >& parts );
  void closeConnection();
  
  bool hasResponse( OdUInt64 );
  OdTvStreamingClientDataPtr getResponse( OdUInt64 id );
  bool cancelCommand( OdUInt64 id );

  Status clientStatus();
protected:
  virtual bool initialize( const char* ip, const char* port ) = 0;
  virtual bool hasConnection() const = 0;
  virtual bool readFromServer( char* pBuffer, int bufferMaxLen, int& bytesRead ) = 0;
  virtual bool writeToServer( const char* pBuffer, int bufferLen, int& bytesSent ) = 0;
  virtual bool connectServer() = 0;
  virtual bool shutdownClient() = 0;

  virtual bool onClientLoopIteration() { return true; }
//reactor methods
protected:
  virtual void onMessage( OdTvMessagePtr pMessage ) override;
  void onMessageSent( OdTvMessagePtr pMessage );
protected:
  bool clientLoop();
  void processIncoming( int nBytes );
private:
  OdVector< char > m_buffer;
  OdTvMessageBuilder m_messageBuilder;
  OdUInt64 m_nRequestId = 1;
  std::mutex m_commandsMutex;
  std::list< OdTvMessagePtr > m_commands;

  std::mutex m_responseMutex;
  std::map< OdUInt64, OdTvStreamingClientDataPtr > m_responses;

  std::mutex m_awaitsMutex;

  Status m_status = Status::kNotConnected;

  bool sendMessage( OdTvMessagePtr pMsg );

  struct AwaitsResponse
  {
    OdUInt64 id;
    OdTvMessage::Commands m_command;
    bool isSingle() const
    {
      return m_command == OdTvMessage::Commands::kGet_FileList_Linear || m_command == OdTvMessage::Commands::kGet_FileList_Partial;
    }
  };

  OdVector< AwaitsResponse > m_awaitsResponses;
  static bool isCorrectResponseType( OdTvMessagePtr pMsg, const AwaitsResponse& resp );
  OdTvMessagePtr getTopCommand();
  void removeTopCommand();

  void setClientStatus( Status st );

  bool m_bClosing = false;
  bool isClosing();
};

typedef std::shared_ptr< OdTvStreamingClient >OdTvStreamingClientPtr;

#endif