/*
 * lftp - file transfer program
 *
 * Copyright (c) 2012-2016 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 DHT_H
#define DHT_H

class Torrent;

class DHT : public SMTask, protected ProtoLog, public ResClient
{
   static const int K = 8;
   static const int MAX_NODES = 160*K;
   static const int MAX_TORRENTS = 1024;
   static const int MAX_PEERS = 60; // per torrent
   static const int MAX_SEND_QUEUE = 256;

   class Node
   {
   public:
      xstring id;
      xstring token;
      xstring my_token;
      xstring my_last_token;
      xstring origin_id;
      sockaddr_u addr;

      Timer good_timer; // 15 minutes, questionable when expired
      Timer token_timer;
      Timer ping_timer; // don't send pings too often
      bool responded; // has ever responded to our query
      bool in_routes; // belongs to the routing table;
      int ping_lost_count;
      int id_change_count;
      int bad_node_count;

      bool IsGood() const { return !good_timer.Stopped(); }
      void SetGood() { good_timer.Reset(); }
      bool IsBad() const { return (!IsGood() && ping_lost_count>=2) || id_change_count>=2; }
      void LostPing() { ping_lost_count++; }
      void ResetLostPing() { ping_lost_count=0; }
      void SetOrigin(const Node *o) { origin_id.set(o->id); }

      const char *GetName() const { return addr.to_string(); }

      Node(const xstring& i,const sockaddr_u& a)
	 : id(i.copy()), addr(a), good_timer(15*60), token_timer(5*60),
	   ping_timer(30), responded(false), in_routes(false),
	   ping_lost_count(0), id_change_count(0), bad_node_count(0)
      {
	 good_timer.Stop();
	 ping_timer.Stop();
      }

      const xstring& GetToken();
      bool TokenIsValid(const xstring& token) const;
   };
   class RouteBucket
   {
   public:
      int prefix_bits;
      xstring prefix;
      xarray<Node*> nodes;
      Timer fresh_timer;

      bool IsFresh() const { return !fresh_timer.Stopped(); }
      void SetFresh() { fresh_timer.Reset(); }
      bool PrefixMatch(const xstring& i,int skew=0) const;
      void RemoveNode(Node *n);
      void RemoveNode(int i);
      bool HasGoodNodes() const {
	 for(int i=0; i<nodes.count(); i++)
	    if(nodes[i]->IsGood())
	       return true;
	 return false;
      }

      RouteBucket(int pb,const xstring& p)
	 : prefix_bits(pb), prefix(p.copy()), fresh_timer(15*60)
      {
	 assert(prefix.length()>=size_t((prefix_bits+7)/8));
      }
      const char *to_string() const;
   };
   class Request
   {
   public:
      Ref<BeNode> data;
      sockaddr_u addr;
      xstring node_id;
      Timer expire_timer;
      bool Expired() const { return expire_timer.Stopped(); }
      const xstring& GetNodeId() const { return node_id; }
      const xstring& GetSearchTarget() const;

      Request(BeNode *b,const sockaddr_u& a,const xstring& id)
	 : data(b), addr(a), node_id(id.copy()), expire_timer(180) {}
   };
   class Search
   {
   public:
      xstring target_id;
      xstring best_node_id;
      xmap<bool> searched;
      int depth;
      Timer search_timer;
      bool want_peers;
      bool noseed;
      bool bootstrap;

      Search(const xstring& i)
	 : target_id(i.copy()), depth(0), search_timer(185),
	   want_peers(false), noseed(false), bootstrap(false) {}

      bool IsFeasible(const xstring &id) const;
      bool IsFeasible(const Node *n) const { return IsFeasible(n->id); }
      void ContinueOn(DHT *d,const Node *n);
      void WantPeers(bool ns) { want_peers=true; noseed=ns; }
      void Bootstrap() { bootstrap=true; }
   };
   class Peer
   {
   public:
      sockaddr_compact compact_addr;
      Timer good_timer;
      bool seed;

      Peer(const sockaddr_compact &a,bool s)
	 : compact_addr(a), good_timer(15*60), seed(s) {}
      bool IsGood() const { return !good_timer.Stopped(); }
   };
   class KnownTorrent
   {
   public:
      xarray_p<Peer> peers;
      void AddPeer(Peer *);
   };
   class BlackList : private ProtoLog
   {
      xmap_p<Timer> bl;
   public:
      bool Listed(const sockaddr_u &a);
      void Add(const sockaddr_u &a,const char *t="1h");
   };

   int af;

   BlackList black_list;
   RateLimit rate_limit;
   RefQueue<Request> send_queue;
   xmap_p<Request> sent_req; // the key is "t"
   Timer sent_req_expire_scan;
   Timer search_cleanup_timer;
   Timer refresh_timer;
   Timer nodes_cleanup_timer;
   Timer save_timer;

   // voting for new external IP
   xmap<unsigned> ip_votes;
   xmap<bool> ip_voted;

   xstring node_id;
   xmap_p<Node> nodes;
   xmap<Node*> node_by_addr;
   RefArray<RouteBucket> routes;
   xmap_p<Search> search;
   xmap_p<KnownTorrent> torrents;

   xqueue_p<xstring> bootstrap_nodes;
   SMTaskRef<Resolver> resolver;

   void Bootstrap();
   void AddNode(Node *);
   void RemoveNode(Node *);
   void ChangeNodeId(Node *n,const xstring& new_node_id);
   void BlackListNode(Node *n,const char *timeout);
   void AddRoute(Node *);
   void RemoveRoute(Node *n);
   bool SplitRoute0();
   Node *FoundNode(const xstring& id,const sockaddr_u& a,bool responded,Search *s=0);
   int FindRoute(const xstring& i,int start=0,int skew=0);
   void FindNodes(const xstring& i,xarray<Node*> &a,int max_count,bool only_good,const xmap<bool> *exclude=0);
   void StartSearch(Search *s);
   void RestartSearch(Search *s);
   void AddPeer(const xstring& ih,const sockaddr_compact& ca,bool seed);
   Node *GetOrigin(const Node *n);

   unsigned t; // transaction id

   BeNode *NewQuery(const char *q,xmap_p<BeNode>& a);
   BeNode *NewReply(const xstring& t0,xmap_p<BeNode>& r);
   BeNode *NewError(const xstring& t0,int code,const char *msg);
   void SendMessage(BeNode *q,const sockaddr_u& a,const xstring& id=xstring::null);
   void SendMessage(Request *);
   bool MaySendMessage();
   static const char *MessageType(BeNode *q);
   static int AddNodesToReply(xmap_p<BeNode> &r,const xstring& target,bool want_n4,bool want_n6);
   int AddNodesToReply(xmap_p<BeNode> &r,const xstring& target,int max_count);

   enum {
      ERR_GENERIC=201,
      ERR_SERVER=202,
      ERR_PROTOCOL=203,
      ERR_UNKNOWN_METHOD=204,
   };

   SMTaskRef<IOBuffer> state_io;

public:
   DHT(int af,const xstring &id);
   ~DHT();
   int Do();

   static void MakeNodeId(xstring &id,const sockaddr_compact& ip,int r=random()/13);
   static bool ValidNodeId(const xstring &id,const sockaddr_compact& ip);
   void Restart();

   void Reconfig(const char *name);
   const char *GetLogContext() { return af==AF_INET?"DHT":"DHT6"; }
   const xstring& GetNodeID() const { return node_id; }

   void SendPing(const sockaddr_u& addr,const xstring& id=xstring::null);
   void SendPing(Node *n);
   int PingQuestionable(const xarray<Node*>& nodes,int limit);
   void AnnouncePeer(const Torrent *);
   void DenouncePeer(const Torrent *);
   void HandlePacket(BeNode *b,const sockaddr_u& src);

   void Save(const SMTaskRef<IOBuffer>& buf);
   void Load(const SMTaskRef<IOBuffer>& buf);
   xstring state_file;
   void Save();
   void Load();

   void AddBootstrapNode(const char *n) { bootstrap_nodes.push(new xstring(n)); }
};

#endif//DHT_H