#include <hyperliquid/exchange.hpp>
#include <hyperliquid/utils/constants.hpp>
#include <hyperliquid/utils/signing.hpp>

#include <algorithm>
#include <cmath>
#include <cctype>
#include <iomanip>
#include <sstream>
#include <stdexcept>

namespace {

std::string lowercase_copy(std::string value) {
    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char ch) {
        return static_cast<char>(std::tolower(ch));
    });
    return value;
}

std::string transfer_amount_to_string(double amount) {
    std::ostringstream oss;
    oss << std::setprecision(15) << std::defaultfloat << amount;
    std::string value = oss.str();
    if (value.find_first_of(".eE") == std::string::npos)
        value += ".0";
    return value;
}

double round_to_significant(double value, int significant_figures) {
    std::ostringstream oss;
    oss << std::setprecision(significant_figures) << std::defaultfloat << value;
    return std::stod(oss.str());
}

} // namespace

namespace hyperliquid {

using signing::float_to_usd_int;
using signing::get_timestamp_ms;
using signing::order_request_to_wire;
using signing::order_wires_to_action;
using signing::private_key_to_address;
using signing::sign_l1_action;
using signing::sign_user_signed_action;

Exchange::Exchange(
    std::string private_key_hex,
    std::string_view base_url,
    std::shared_ptr<Info> info,
    std::optional<std::string> vault_address)
    : Exchange(std::move(private_key_hex), base_url, std::move(info), std::move(vault_address), {})
{
}

Exchange::Exchange(
    std::string private_key_hex,
    std::string_view base_url,
    std::shared_ptr<Info> info,
    std::optional<std::string> vault_address,
    std::optional<std::string> account_address)
    : Api(base_url)
    , private_key_(std::move(private_key_hex))
    , vault_address_(std::move(vault_address))
    , account_address_(std::move(account_address))
    , info_(std::move(info))
    , is_mainnet_(base_url_ == MAINNET_API_URL) // normalized by Api (no trailing slash)
{
    wallet_ = private_key_to_address(private_key_);
    info_->load_meta();
}

// Helpers

int Exchange::asset_index(std::string_view coin) {
    return info_->name_to_asset(coin);
}

std::string Exchange::effective_account_address() const {
    if (vault_address_)
        return *vault_address_;
    if (account_address_)
        return *account_address_;
    return wallet_;
}

nlohmann::json Exchange::post_action(nlohmann::ordered_json action) {
    return post_action(std::move(action), vault_address_, vault_address_);
}

nlohmann::json Exchange::post_action(
    nlohmann::ordered_json action,
    std::optional<std::string> signing_vault_address,
    std::optional<std::string> payload_vault_address)
{
    const int64_t nonce = get_timestamp_ms();
    const auto sig = sign_l1_action(
        private_key_, action, signing_vault_address, nonce, is_mainnet_);

    nlohmann::json req;
    req["action"] = action;
    req["nonce"] = nonce;
    req["signature"] = {{"r", sig.r}, {"s", sig.s}, {"v", sig.v}};
    if (payload_vault_address)
        req["vaultAddress"] = *payload_vault_address;
    else
        req["vaultAddress"] = nullptr;

    return post("/exchange", req);
}

nlohmann::json Exchange::post_user_signed_action(
    nlohmann::ordered_json action,
    const std::vector<std::pair<std::string, std::string>>& payload_types,
    std::string_view primary_type)
{
    return post_user_signed_action(std::move(action), payload_types, primary_type, vault_address_);
}

nlohmann::json Exchange::post_user_signed_action(
    nlohmann::ordered_json action,
    const std::vector<std::pair<std::string, std::string>>& payload_types,
    std::string_view primary_type,
    std::optional<std::string> payload_vault_address)
{
    const int64_t nonce = get_timestamp_ms();

    const char* ts_key = "nonce";
    for (const auto& [field_name, _field_type] : payload_types) {
        if (field_name == "time") {
            ts_key = "time";
            break;
        }
    }
    action[ts_key] = nonce;

    const auto sig = sign_user_signed_action(
        private_key_, action, payload_types, primary_type, is_mainnet_);

    nlohmann::json req;
    req["action"] = action;
    req["nonce"] = nonce;
    req["signature"] = {{"r", sig.r}, {"s", sig.s}, {"v", sig.v}};
    if (payload_vault_address)
        req["vaultAddress"] = *payload_vault_address;
    else
        req["vaultAddress"] = nullptr;

    return post("/exchange", req);
}

double Exchange::slippage_price(
    std::string_view coin, bool is_buy, double slippage, std::optional<double> px)
{
    const std::string canonical_coin = info_->canonical_coin(coin);
    const int asset = asset_index(coin);
    const bool is_spot = asset >= 10000;
    const int max_decimals = is_spot ? 8 : 6;
    const int decimal_places =
        std::max(0, max_decimals - info_->asset_to_sz_decimals.at(asset));

    double price = px.value_or(std::stod(info_->all_mids().at(canonical_coin).get<std::string>()));
    price *= is_buy ? (1.0 + slippage) : (1.0 - slippage);
    price = round_to_significant(price, 5);

    const double scale = std::pow(10.0, decimal_places);
    return std::round(price * scale) / scale;
}

// Order management

nlohmann::json Exchange::order(
    std::string_view coin, bool is_buy,
    double sz, double limit_px,
    const OrderType& order_type,
    bool reduce_only,
    std::optional<Cloid> cloid,
    std::optional<BuilderInfo> builder,
    const std::string& grouping)
{
    OrderRequest req;
    req.coin = std::string(coin);
    req.is_buy = is_buy;
    req.sz = sz;
    req.limit_px = limit_px;
    req.order_type = order_type;
    req.reduce_only = reduce_only;
    req.cloid = std::move(cloid);

    return bulk_orders({std::move(req)}, std::move(builder), grouping);
}

nlohmann::json Exchange::bulk_orders(
    std::vector<OrderRequest> orders,
    std::optional<BuilderInfo> builder,
    const std::string& grouping)
{
    std::vector<nlohmann::ordered_json> wires;
    wires.reserve(orders.size());
    for (const auto& req : orders)
        wires.push_back(order_request_to_wire(req, asset_index(req.coin)));

    if (builder)
        builder->b = lowercase_copy(builder->b);

    auto action = order_wires_to_action(std::move(wires), grouping, std::move(builder));
    return post_action(std::move(action));
}

nlohmann::json Exchange::market_open(
    std::string_view coin, bool is_buy, double sz,
    double slippage, std::optional<Cloid> cloid)
{
    const double px = slippage_price(coin, is_buy, slippage);
    return order(coin, is_buy, sz, px,
                 LimitOrderType{Tif::Ioc}, false, std::move(cloid));
}

nlohmann::json Exchange::market_close(
    std::string_view coin, std::optional<double> sz,
    double slippage, std::optional<Cloid> cloid)
{
    const std::string canonical_coin = info_->canonical_coin(coin);
    const auto state = info_->user_state(effective_account_address());
    for (const auto& pos_entry : state.at("assetPositions")) {
        const auto& pos = pos_entry.at("position");
        if (pos.value("coin", "") != canonical_coin)
            continue;

        const double szi = std::stod(pos.at("szi").get<std::string>());
        const bool is_buy = szi < 0.0;
        const double close_sz = sz.value_or(std::abs(szi));
        const double px = slippage_price(canonical_coin, is_buy, slippage);
        return order(canonical_coin, is_buy, close_sz, px,
                     LimitOrderType{Tif::Ioc}, true, std::move(cloid));
    }

    throw std::runtime_error("No open position for " + std::string(coin));
}

// Cancel

nlohmann::json Exchange::cancel(std::string_view coin, int64_t oid) {
    return bulk_cancel({{std::string(coin), oid}});
}

nlohmann::json Exchange::cancel_by_cloid(std::string_view coin, const Cloid& cloid) {
    return bulk_cancel_by_cloid({{std::string(coin), cloid}});
}

nlohmann::json Exchange::bulk_cancel(std::vector<CancelRequest> cancels) {
    nlohmann::ordered_json action;
    action["type"] = "cancel";
    auto arr = nlohmann::ordered_json::array();
    for (const auto& cancel : cancels) {
        nlohmann::ordered_json item;
        item["a"] = asset_index(cancel.coin);
        item["o"] = cancel.oid;
        arr.push_back(std::move(item));
    }
    action["cancels"] = std::move(arr);
    return post_action(std::move(action));
}

nlohmann::json Exchange::bulk_cancel_by_cloid(std::vector<CancelByCloidRequest> cancels) {
    nlohmann::ordered_json action;
    action["type"] = "cancelByCloid";
    auto arr = nlohmann::ordered_json::array();
    for (const auto& cancel : cancels) {
        nlohmann::ordered_json item;
        item["asset"] = asset_index(cancel.coin);
        item["cloid"] = std::string(cancel.cloid.to_raw());
        arr.push_back(std::move(item));
    }
    action["cancels"] = std::move(arr);
    return post_action(std::move(action));
}

nlohmann::json Exchange::schedule_cancel(std::optional<int64_t> time_ms) {
    nlohmann::ordered_json action;
    action["type"] = "scheduleCancel";
    if (time_ms)
        action["time"] = *time_ms;
    return post_action(std::move(action));
}

// Modify

nlohmann::json Exchange::modify_order(int64_t oid, const OrderRequest& new_order) {
    return bulk_modify_orders({{oid, new_order}});
}

nlohmann::json Exchange::bulk_modify_orders(std::vector<ModifyRequest> mods) {
    nlohmann::ordered_json action;
    action["type"] = "batchModify";
    auto arr = nlohmann::ordered_json::array();
    for (const auto& mod : mods) {
        nlohmann::ordered_json item;
        item["oid"] = mod.oid;
        item["order"] = order_request_to_wire(mod.order, asset_index(mod.order.coin));
        arr.push_back(std::move(item));
    }
    action["modifies"] = std::move(arr);
    return post_action(std::move(action));
}

// Leverage & margin

nlohmann::json Exchange::update_leverage(
    std::string_view coin, bool is_cross, int leverage)
{
    nlohmann::ordered_json action;
    action["type"] = "updateLeverage";
    action["asset"] = asset_index(coin);
    action["isCross"] = is_cross;
    action["leverage"] = leverage;
    return post_action(std::move(action));
}

nlohmann::json Exchange::update_isolated_margin(std::string_view coin, double amount) {
    nlohmann::ordered_json action;
    action["type"] = "updateIsolatedMargin";
    action["asset"] = asset_index(coin);
    action["isBuy"] = true;
    action["ntli"] = float_to_usd_int(amount);
    return post_action(std::move(action));
}

// Transfers

nlohmann::json Exchange::usd_class_transfer(double amount, bool to_perp) {
    nlohmann::ordered_json action;
    action["type"] = "usdClassTransfer";
    action["amount"] = transfer_amount_to_string(amount);
    if (vault_address_)
        action["amount"] = action["amount"].get<std::string>() + " subaccount:" + *vault_address_;
    action["toPerp"] = to_perp;

    const std::vector<std::pair<std::string, std::string>> types = {
        {"hyperliquidChain", "string"},
        {"amount", "string"},
        {"toPerp", "bool"},
        {"nonce", "uint64"},
    };
    return post_user_signed_action(
        std::move(action), types, "HyperliquidTransaction:UsdClassTransfer", {});
}

nlohmann::json Exchange::usd_transfer(double amount, std::string_view destination) {
    nlohmann::ordered_json action;
    action["type"] = "usdSend";
    action["destination"] = destination;
    action["amount"] = transfer_amount_to_string(amount);

    const std::vector<std::pair<std::string, std::string>> types = {
        {"hyperliquidChain", "string"},
        {"destination", "string"},
        {"amount", "string"},
        {"time", "uint64"},
    };
    return post_user_signed_action(std::move(action), types, "HyperliquidTransaction:UsdSend");
}

nlohmann::json Exchange::spot_transfer(
    double amount, std::string_view destination, std::string_view token)
{
    nlohmann::ordered_json action;
    action["type"] = "spotSend";
    action["destination"] = destination;
    action["token"] = token;
    action["amount"] = transfer_amount_to_string(amount);

    const std::vector<std::pair<std::string, std::string>> types = {
        {"hyperliquidChain", "string"},
        {"destination", "string"},
        {"token", "string"},
        {"amount", "string"},
        {"time", "uint64"},
    };
    return post_user_signed_action(std::move(action), types, "HyperliquidTransaction:SpotSend");
}

nlohmann::json Exchange::withdraw_from_bridge(
    double amount, std::string_view destination)
{
    nlohmann::ordered_json action;
    action["type"] = "withdraw3";
    action["destination"] = destination;
    action["amount"] = transfer_amount_to_string(amount);

    const std::vector<std::pair<std::string, std::string>> types = {
        {"hyperliquidChain", "string"},
        {"destination", "string"},
        {"amount", "string"},
        {"time", "uint64"},
    };
    return post_user_signed_action(std::move(action), types, "HyperliquidTransaction:Withdraw");
}

// Agent / builder

nlohmann::json Exchange::approve_agent(
    std::string_view agent_address, std::string_view agent_name)
{
    nlohmann::ordered_json action;
    action["type"] = "approveAgent";
    action["agentAddress"] = lowercase_copy(std::string(agent_address));
    action["agentName"] = agent_name;

    const std::vector<std::pair<std::string, std::string>> types = {
        {"hyperliquidChain", "string"},
        {"agentAddress", "address"},
        {"agentName", "string"},
        {"nonce", "uint64"},
    };
    return post_user_signed_action(std::move(action), types, "HyperliquidTransaction:ApproveAgent");
}

nlohmann::json Exchange::approve_builder_fee(
    std::string_view builder, std::string_view max_fee_rate)
{
    nlohmann::ordered_json action;
    action["type"] = "approveBuilderFee";
    action["maxFeeRate"] = max_fee_rate;
    action["builder"] = lowercase_copy(std::string(builder));

    const std::vector<std::pair<std::string, std::string>> types = {
        {"hyperliquidChain", "string"},
        {"maxFeeRate", "string"},
        {"builder", "address"},
        {"nonce", "uint64"},
    };
    return post_user_signed_action(
        std::move(action), types, "HyperliquidTransaction:ApproveBuilderFee");
}

// Sub-accounts

nlohmann::json Exchange::create_sub_account(std::string_view name) {
    nlohmann::ordered_json action;
    action["type"] = "createSubAccount";
    action["name"] = name;
    return post_action(std::move(action), {}, {});
}

nlohmann::json Exchange::sub_account_transfer(
    double usd, bool to_sub, std::string_view sub_account_user)
{
    nlohmann::ordered_json action;
    action["type"] = "subAccountTransfer";
    action["subAccountUser"] = lowercase_copy(std::string(sub_account_user));
    action["isDeposit"] = to_sub;
    action["usd"] = float_to_usd_int(usd);
    return post_action(std::move(action), {}, {});
}

} // namespace hyperliquid