/*

Copyright (c) 2003, Magnus Jonsson
Copyright (c) 2003, 2006, 2008-2020, Arvid Norberg
Copyright (c) 2016, Alden Torres
Copyright (c) 2017, 2020, Steven Siloti
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the distribution.
    * Neither the name of the author nor the names of its
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

*/

#include "libtorrent/config.hpp"
#include "libtorrent/session.hpp"
#include "libtorrent/extensions.hpp"
#include "libtorrent/aux_/session_impl.hpp"
#include "libtorrent/aux_/session_call.hpp"
#include "libtorrent/extensions.hpp" // for add_peer_flags_t
#include "libtorrent/disk_interface.hpp"
#include "libtorrent/mmap_disk_io.hpp"
#include "libtorrent/posix_disk_io.hpp"
#include "libtorrent/platform_util.hpp"

namespace libtorrent {

#ifndef TORRENT_DISABLE_EXTENSIONS
	// declared in extensions.hpp
	// remove this once C++17 is required
	constexpr feature_flags_t plugin::optimistic_unchoke_feature;
	constexpr feature_flags_t plugin::tick_feature;
	constexpr feature_flags_t plugin::dht_request_feature;
	constexpr feature_flags_t plugin::alert_feature;
#endif

namespace aux {
	constexpr torrent_list_index_t session_interface::torrent_state_updates;
	constexpr torrent_list_index_t session_interface::torrent_want_tick;
	constexpr torrent_list_index_t session_interface::torrent_want_peers_download;
	constexpr torrent_list_index_t session_interface::torrent_want_peers_finished;
	constexpr torrent_list_index_t session_interface::torrent_want_scrape;
	constexpr torrent_list_index_t session_interface::torrent_downloading_auto_managed;
	constexpr torrent_list_index_t session_interface::torrent_seeding_auto_managed;
	constexpr torrent_list_index_t session_interface::torrent_checking_auto_managed;
}

#ifndef TORRENT_DISABLE_EXTENSIONS
constexpr add_peer_flags_t torrent_plugin::first_time;
constexpr add_peer_flags_t torrent_plugin::filtered;
#endif

namespace {

#if defined TORRENT_ASIO_DEBUGGING
	void wait_for_asio_handlers()
	{
		int counter = 0;
		while (log_async())
		{
			std::this_thread::sleep_for(milliseconds(300));
			++counter;
			std::printf("\x1b[2J\x1b[0;0H\x1b[33m==== Waiting to shut down: %d ==== \x1b[0m\n\n"
				, counter);
		}
		async_dec_threads();

		std::fprintf(stderr, "\n\nEXPECTS NO MORE ASYNC OPS\n\n\n");
	}
#endif
} // anonymous namespace

	settings_pack min_memory_usage()
	{
		settings_pack set;
#if TORRENT_ABI_VERSION == 1
		// receive data directly into disk buffers
		// this yields more system calls to read() and
		// kqueue(), but saves RAM.
		set.set_bool(settings_pack::contiguous_recv_buffer, false);
#endif

		set.set_int(settings_pack::max_peer_recv_buffer_size, 32 * 1024 + 200);

		set.set_int(settings_pack::disk_io_write_mode, settings_pack::disable_os_cache);
		set.set_int(settings_pack::disk_io_read_mode, settings_pack::disable_os_cache);

		// keep 2 blocks outstanding when hashing
		set.set_int(settings_pack::checking_mem_usage, 2);

		// don't use any extra threads to do SHA-1 hashing
		set.set_int(settings_pack::aio_threads, 1);

		set.set_int(settings_pack::alert_queue_size, 100);

		set.set_int(settings_pack::max_out_request_queue, 300);
		set.set_int(settings_pack::max_allowed_in_request_queue, 100);

		// setting this to a low limit, means more
		// peers are more likely to request from the
		// same piece. Which means fewer partial
		// pieces and fewer entries in the partial
		// piece list
		set.set_int(settings_pack::whole_pieces_threshold, 2);
		set.set_bool(settings_pack::use_parole_mode, false);
		set.set_bool(settings_pack::prioritize_partial_pieces, true);

		// connect to 5 peers per second
		set.set_int(settings_pack::connection_speed, 5);

		// only have 4 files open at a time
		set.set_int(settings_pack::file_pool_size, 4);

		// we want to keep the peer list as small as possible
		set.set_bool(settings_pack::allow_multiple_connections_per_ip, false);
		set.set_int(settings_pack::max_failcount, 2);
		set.set_int(settings_pack::inactivity_timeout, 120);

		// whenever a peer has downloaded one block, write
		// it to disk, and don't read anything from the
		// socket until the disk write is complete
		set.set_int(settings_pack::max_queued_disk_bytes, 1);

		// never keep more than one 16kB block in
		// the send buffer
		set.set_int(settings_pack::send_buffer_watermark, 9);

		set.set_bool(settings_pack::close_redundant_connections, true);

		set.set_int(settings_pack::max_peerlist_size, 500);
		set.set_int(settings_pack::max_paused_peerlist_size, 50);

		// udp trackers are cheaper to talk to
		set.set_bool(settings_pack::prefer_udp_trackers, true);

		set.set_int(settings_pack::max_rejects, 10);

		set.set_int(settings_pack::recv_socket_buffer_size, 16 * 1024);
		set.set_int(settings_pack::send_socket_buffer_size, 16 * 1024);
		return set;
	}

	settings_pack high_performance_seed()
	{
		settings_pack set;
		// don't throttle TCP, assume there is
		// plenty of bandwidth
		set.set_int(settings_pack::mixed_mode_algorithm, settings_pack::prefer_tcp);

		set.set_int(settings_pack::max_out_request_queue, 1500);
		set.set_int(settings_pack::max_allowed_in_request_queue, 2000);

		set.set_int(settings_pack::max_peer_recv_buffer_size, 5 * 1024 * 1024);

		// we will probably see a high rate of alerts, make it less
		// likely to loose alerts
		set.set_int(settings_pack::alert_queue_size, 10000);

		// allow 500 files open at a time
		set.set_int(settings_pack::file_pool_size, 500);

		// don't update access time for each read/write
		set.set_bool(settings_pack::no_atime_storage, true);

		// as a seed box, we must accept multiple peers behind
		// the same NAT
//		set.set_bool(settings_pack::allow_multiple_connections_per_ip, true);

		// connect to 50 peers per second
		set.set_int(settings_pack::connection_speed, 500);

		// allow 8000 peer connections
		set.set_int(settings_pack::connections_limit, 8000);

		// allow lots of peers to try to connect simultaneously
		set.set_int(settings_pack::listen_queue_size, 3000);

		// unchoke all peers
		set.set_int(settings_pack::unchoke_slots_limit, -1);

		// the max number of bytes pending write before we throttle
		// download rate
		set.set_int(settings_pack::max_queued_disk_bytes, 7 * 1024 * 1024);

		// prevent fast pieces to interfere with suggested pieces
		// since we unchoke everyone, we don't need fast pieces anyway
		set.set_int(settings_pack::allowed_fast_set_size, 0);

		// suggest pieces in the read cache for higher cache hit rate
		set.set_int(settings_pack::suggest_mode, settings_pack::suggest_read_cache);

		set.set_bool(settings_pack::close_redundant_connections, true);

		set.set_int(settings_pack::max_rejects, 10);

		set.set_int(settings_pack::send_not_sent_low_watermark, 524288);

		// don't let connections linger for too long
		set.set_int(settings_pack::request_timeout, 10);
		set.set_int(settings_pack::peer_timeout, 20);
		set.set_int(settings_pack::inactivity_timeout, 20);

		set.set_int(settings_pack::active_limit, 20000);
		set.set_int(settings_pack::active_tracker_limit, 2000);
		set.set_int(settings_pack::active_dht_limit, 600);
		set.set_int(settings_pack::active_seeds, 2000);

		set.set_int(settings_pack::choking_algorithm, settings_pack::fixed_slots_choker);

		// of 500 ms, and a send rate of 4 MB/s, the upper
		// limit should be 2 MB
		set.set_int(settings_pack::send_buffer_watermark, 3 * 1024 * 1024);

		// put 1.5 seconds worth of data in the send buffer
		// this gives the disk I/O more heads-up on disk
		// reads, and can maximize throughput
		set.set_int(settings_pack::send_buffer_watermark_factor, 150);

		// always stuff at least 1 MiB down each peer
		// pipe, to quickly ramp up send rates
		set.set_int(settings_pack::send_buffer_low_watermark, 1 * 1024 * 1024);

		// don't retry peers if they fail once. Let them
		// connect to us if they want to
		set.set_int(settings_pack::max_failcount, 1);

		// number of disk threads for low level file operations
		set.set_int(settings_pack::aio_threads, 8);

		set.set_int(settings_pack::checking_mem_usage, 2048);

		return set;
	}

	void session::start(session_flags_t const flags, session_params&& params, io_context* ios)
	{
		bool const internal_executor = ios == nullptr;

		if (internal_executor)
		{
			// the user did not provide an executor, we have to use our own
			m_io_service = std::make_shared<io_context>(1);
			ios = m_io_service.get();
		}

#if TORRENT_ABI_VERSION <= 2
#ifndef TORRENT_DISABLE_DHT
		// in case the session_params has its dht_settings in use, pick out the
		// non-default settings from there and move them into the main settings.
		// any conflicting options set in main settings take precedence
		{
		dht::dht_settings const def_sett{};
#define SET_BOOL(name) if (!params.settings.has_val(settings_pack::dht_ ## name) && \
	def_sett.name != params.dht_settings.name) \
		params.settings.set_bool(settings_pack::dht_ ## name, params.dht_settings.name)
#define SET_INT(name) if (!params.settings.has_val(settings_pack::dht_ ## name) && \
	def_sett.name != params.dht_settings.name) \
		params.settings.set_int(settings_pack::dht_ ## name, params.dht_settings.name)

		SET_INT(max_peers_reply);
		SET_INT(search_branching);
		SET_INT(max_fail_count);
		SET_INT(max_torrents);
		SET_INT(max_dht_items);
		SET_INT(max_peers);
		SET_INT(max_torrent_search_reply);
		SET_BOOL(restrict_routing_ips);
		SET_BOOL(restrict_search_ips);
		SET_BOOL(extended_routing_table);
		SET_BOOL(aggressive_lookups);
		SET_BOOL(privacy_lookups);
		SET_BOOL(enforce_node_id);
		SET_BOOL(ignore_dark_internet);
		SET_INT(block_timeout);
		SET_INT(block_ratelimit);
		SET_BOOL(read_only);
		SET_INT(item_lifetime);
		SET_INT(upload_rate_limit);
		SET_INT(sample_infohashes_interval);
		SET_INT(max_infohashes_sample_count);
#undef SET_BOOL
#undef SET_INT
		}
#endif
#endif

		m_impl = std::make_shared<aux::session_impl>(std::ref(*ios)
			, std::move(params.settings)
			, std::move(params.disk_io_constructor)
			, flags);
		*static_cast<session_handle*>(this) = session_handle(m_impl);

#ifndef TORRENT_DISABLE_EXTENSIONS
		for (auto& ext : params.extensions)
		{
			ext->load_state(params.ext_state);
			m_impl->add_ses_extension(std::move(ext));
		}
#endif

#ifndef TORRENT_DISABLE_DHT
		m_impl->set_dht_state(std::move(params.dht_state));

		TORRENT_ASSERT(params.dht_storage_constructor);
		m_impl->set_dht_storage(std::move(params.dht_storage_constructor));
#endif

		if (!params.ip_filter.empty())
		{
			std::shared_ptr<ip_filter> copy = std::make_shared<ip_filter>(std::move(params.ip_filter));
			m_impl->set_ip_filter(std::move(copy));
		}

		m_impl->start_session();

		if (internal_executor)
		{
			// start a thread for the message pump
			auto s = m_io_service;
			m_thread = std::make_shared<std::thread>([=]
			{
				set_thread_name("Network");
				s->run();
			});
		}
	}

#if TORRENT_ABI_VERSION <= 2
	void session::start(session_flags_t const flags, settings_pack&& sp, io_context* ios)
	{
		if (flags & add_default_plugins)
		{
			session_params sp_(std::move(sp));
			start(flags, std::move(sp_), ios);
		}
		else
		{
			session_params sp_(std::move(sp), {});
			start(flags, std::move(sp_), ios);
		}
	}
#endif

	session::session(session&&) = default;

	session::session(session_params const& params)
	{
		start({}, session_params(params), nullptr);
	}

	session::session(session_params&& params)
	{
		start({}, std::move(params), nullptr);
	}

	session::session(session_params const& params, session_flags_t const flags)
	{
		start(flags, session_params(params), nullptr);
	}

	session::session(session_params&& params, session_flags_t const flags)
	{
		start(flags, std::move(params), nullptr);
	}

	session::session()
	{
		session_params params;
		start({}, std::move(params), nullptr);
	}

	session::session(session_params&& params, io_context& ios)
	{
		start({}, std::move(params), &ios);
	}

	session::session(session_params const& params, io_context& ios)
	{
		start({}, session_params(params), &ios);
	}

	session::session(session_params&& params, io_context& ios, session_flags_t const flags)
	{
		start(flags, std::move(params), &ios);
	}

	session::session(session_params const& params, io_context& ios, session_flags_t const flags)
	{
		start(flags, session_params(params), &ios);
	}


#if TORRENT_ABI_VERSION <= 2
	session::session(settings_pack&& pack, session_flags_t const flags)
	{
		start(flags, std::move(pack), nullptr);
	}

	session::session(settings_pack const& pack, session_flags_t const flags)
	{
		start(flags, settings_pack(pack), nullptr);
	}

	session::session(settings_pack&& pack, io_context& ios, session_flags_t const flags)
	{
		start(flags, std::move(pack), &ios);
	}

	session::session(settings_pack const& pack, io_context& ios, session_flags_t const flags)
	{
		start(flags, settings_pack(pack), &ios);
	}
#endif

#if TORRENT_ABI_VERSION == 1
#include "libtorrent/aux_/disable_deprecation_warnings_push.hpp"
	session::session(fingerprint const& print, session_flags_t const flags
		, alert_category_t const alert_mask)
	{
		settings_pack pack;
		pack.set_int(settings_pack::alert_mask, int(alert_mask));
		pack.set_str(settings_pack::peer_fingerprint, print.to_string());
		if (!(flags & start_default_features))
		{
			pack.set_bool(settings_pack::enable_upnp, false);
			pack.set_bool(settings_pack::enable_natpmp, false);
			pack.set_bool(settings_pack::enable_lsd, false);
			pack.set_bool(settings_pack::enable_dht, false);
		}

		start(flags, std::move(pack), nullptr);
	}

	session::session(fingerprint const& print, std::pair<int, int> listen_port_range
		, char const* listen_interface, session_flags_t const flags
		, alert_category_t const alert_mask)
	{
		TORRENT_ASSERT(listen_port_range.first > 0);
		TORRENT_ASSERT(listen_port_range.first <= listen_port_range.second);

		settings_pack pack;
		pack.set_int(settings_pack::alert_mask, int(alert_mask));
		pack.set_int(settings_pack::max_retry_port_bind, listen_port_range.second - listen_port_range.first);
		pack.set_str(settings_pack::peer_fingerprint, print.to_string());
		char if_string[100];

		if (listen_interface == nullptr) listen_interface = "0.0.0.0";
		std::snprintf(if_string, sizeof(if_string), "%s:%d", listen_interface, listen_port_range.first);
		pack.set_str(settings_pack::listen_interfaces, if_string);

		if (!(flags & start_default_features))
		{
			pack.set_bool(settings_pack::enable_upnp, false);
			pack.set_bool(settings_pack::enable_natpmp, false);
			pack.set_bool(settings_pack::enable_lsd, false);
			pack.set_bool(settings_pack::enable_dht, false);
		}
		start(flags, std::move(pack), nullptr);
	}
#include "libtorrent/aux_/disable_warnings_pop.hpp"
#endif // TORRENT_ABI_VERSION
	session& session::operator=(session&&) & = default;

	session::~session()
	{
		if (!m_impl) return;

		aux::dump_call_profile();

		// capture the shared_ptr in the dispatched function
		// to keep the session_impl alive
		m_impl->call_abort();

		if (m_thread && m_thread.use_count() == 1)
		{
#if defined TORRENT_ASIO_DEBUGGING
			wait_for_asio_handlers();
#endif
			m_thread->join();
		}
	}

	session_proxy session::abort()
	{
		// stop calling the alert notify function now, to avoid it thinking the
		// session is still alive
		m_impl->alerts().set_notify_function({});
		return session_proxy(m_io_service, m_thread, m_impl);
	}

	session_proxy::session_proxy() = default;
	session_proxy::session_proxy(std::shared_ptr<io_context> ios
		, std::shared_ptr<std::thread> t
		, std::shared_ptr<aux::session_impl> impl)
		: m_io_service(std::move(ios))
		, m_thread(std::move(t))
		, m_impl(std::move(impl))
	{}
	session_proxy::session_proxy(session_proxy const&) = default;
	session_proxy& session_proxy::operator=(session_proxy const&) & = default;
	session_proxy::session_proxy(session_proxy&&) noexcept = default;
	session_proxy& session_proxy::operator=(session_proxy&&) & noexcept = default;
	session_proxy::~session_proxy()
	{
		if (m_thread && m_thread.use_count() == 1)
		{
#if defined TORRENT_ASIO_DEBUGGING
			wait_for_asio_handlers();
#endif
			m_thread->join();
		}
	}

	TORRENT_EXPORT std::unique_ptr<disk_interface> default_disk_io_constructor(
		io_context& ios, settings_interface const& sett, counters& cnt)
	{
#if TORRENT_HAVE_MMAP || TORRENT_HAVE_MAP_VIEW_OF_FILE
		// TODO: In C++17. use if constexpr instead
#include "libtorrent/aux_/disable_deprecation_warnings_push.hpp"
		if (sizeof(void*) == 8)
			return mmap_disk_io_constructor(ios, sett, cnt);
		else
			return posix_disk_io_constructor(ios, sett, cnt);
#include "libtorrent/aux_/disable_warnings_pop.hpp"
#else
		return posix_disk_io_constructor(ios, sett, cnt);
#endif
	}

}
