/*
 * lftp - file transfer program
 *
 * Copyright (c) 1996-2014 by Alexander V. Lukyanov (lav@yars.free.net)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef TORRENTTRACKER_H
#define TORRENTTRACKER_H

#include "url.h"

class TrackerBackend;
class TorrentTracker : public SMTask, protected ProtoLog
{
   friend class Torrent;
   friend class TrackerBackend;

   Torrent *parent;

   xarray_p<xstring> tracker_urls;
   int current_tracker;
   SMTaskRef<TrackerBackend> backend;
   Timer tracker_timer;
   Timer tracker_timeout_timer;
   xstring tracker_id;
   bool started;
   Ref<Error> error;
   int tracker_no;

   TorrentTracker(Torrent *p,const char *url);
   void AddURL(const char *url);
   int Do();

   void Start();
   void Shutdown();

   void SendTrackerRequest(const char *event);

   void SetError(const char *e);
   bool Failed() const { return error!=0 || tracker_urls.count()==0; }
   const char *ErrorText() const { return error->Text(); }

   void NextTracker();
   void CreateTrackerBackend();
   const char *GetLogContext() { return GetURL(); }

public:
   ~TorrentTracker() {}
   const char *NextRequestIn() const {
      return tracker_timer.TimeLeft().toString(
	 TimeInterval::TO_STR_TRANSLATE|TimeInterval::TO_STR_TERSE);
   }
   const char *GetURL() const {
      return tracker_urls[current_tracker]->get();
   }
   const char *Status() const;
   bool IsActive() const;
   void TrackerRequestFinished() { tracker_timer.Reset(); }
   void SetInterval(unsigned i) {
      if(i<30)
	 i=30;
      tracker_timer.Set(i);
      LogNote(4,"Tracker interval is %u",i);
   }
   void SetTrackerID(const xstring& id) {
      if(id)
	 tracker_id.set(id);
   }
   bool AddPeerCompact(const char *a,int len) const;
   bool AddPeer(const xstring& addr,int port) const;
   bool ShuttingDown();
};

class TrackerBackend : public SMTask, protected ProtoLog
{
protected:
   TorrentTracker *master;
   void SetError(const char *e) { master->SetError(e); }

   const char *GetURL() const { return master->GetURL(); }
   const xstring& GetInfoHash() const;
   const xstring& GetMyPeerId() const;
   int GetPort() const;
   unsigned long long GetTotalSent() const;
   unsigned long long GetTotalRecv() const;
   unsigned long long GetTotalLeft() const;
   bool HasMetadata() const;
   bool Complete() const;
   int GetWantedPeersCount() const;
   const xstring& GetMyKey() const;
   unsigned GetMyKeyNum() const;
   const char *GetTrackerId() const;
   void SetTrackerID(const xstring& id) const { master->SetTrackerID(id); }
   void SetInterval(unsigned i) const { master->SetInterval(i); }
   bool AddPeerCompact(const char *a,int len) const { return master->AddPeerCompact(a,len); }
   bool AddPeer(const xstring& addr,int port) const { return master->AddPeer(addr,port); }
   void NextTracker() const { master->NextTracker(); }
   bool ShuttingDown() const;
   void Started() const;
   void TrackerRequestFinished() const;
   const char *GetLogContext() { return master->GetLogContext(); }

public:
   TrackerBackend(TorrentTracker *m) : master(m) {}
   virtual ~TrackerBackend() {}
   virtual bool IsActive() const = 0;
   virtual void SendTrackerRequest(const char *event) = 0;
   virtual const char *Status() const = 0;
};
class HttpTracker : public TrackerBackend
{
   FileAccessRef t_session;
   SMTaskRef<IOBuffer> tracker_reply;
   int HandleTrackerReply();
public:
   bool IsActive() const { return tracker_reply!=0; }
   void SendTrackerRequest(const char *event);
   HttpTracker(TorrentTracker *m,ParsedURL *u)
      : TrackerBackend(m), t_session(FileAccess::New(u)) {}
   ~HttpTracker() {}
   int Do();
   const char *Status() const { return t_session->CurrentStatus(); }
};
class UdpTracker : public TrackerBackend, protected Networker
{
   xstring_c hostname;
   xstring_c portname;

   SMTaskRef<Resolver> resolver;

   xarray<sockaddr_u> peer;
   int peer_curr;
   void	 NextPeer();

   int sock;   // udp socket for packet exchange

   Timer timeout_timer;
   int try_number;   // timeout = 60 * 2^try_number

   bool has_connection_id;
   unsigned long long connection_id;

   enum action_t {
      a_none=-1,
      a_connect=0,
      a_announce=1,
      a_scrape=2,
      a_error=3,
      a_announce6=4,
   };
   enum event_t {
      ev_idle=-1,
      ev_none=0,
      ev_completed=1,
      ev_started=2,
      ev_stopped=3,
   };
   enum magic_t {
      connect_magic=0x41727101980ULL,
   };
   static const char *EventToString(event_t e);

   unsigned transaction_id;
   action_t current_action;
   event_t current_event;

   bool SendPacket(Buffer& req);
   bool SendConnectRequest();
   bool SendEventRequest();
   bool RecvReply();

   unsigned NewTransactionId() { return transaction_id=random(); }

public:
   UdpTracker(TorrentTracker *m,ParsedURL *u)
      : TrackerBackend(m),
        hostname(u->host.get()), portname(u->port.get()),
        peer_curr(0), sock(-1), timeout_timer(60), try_number(0),
        has_connection_id(false), connection_id(0),
	current_action(a_none), current_event(ev_idle) {}
   ~UdpTracker() {
      if(sock!=-1)
	 close(sock);
   }
   int Do();
   bool IsActive() const { return current_event!=ev_idle; }
   void SendTrackerRequest(const char *event);
   const char *Status() const;
};

#endif // TORRENTTRACKER_H