Trading

using System;
using System.Linq;
using GF.Api;
using GF.Api.Connection;
using GF.Api.Contracts;
using GF.Api.Contracts.Lookup;
using GF.Api.Contracts.Lookup.Request;
using GF.Api.Impl;
using GF.Api.Threading;
using GF.Api.Values.Contracts.Lookup;

namespace GettingStarted.Trading
{
    internal class Program
    {
        private static SymbolLookupRequestID _frontEsSymbolLookupRequestID;
        private static System.Timers.Timer _statusTimer;

        private static void Main(string[] args)
        {
            Console.WriteLine("Hello OEC!");

            var gfClient = GFApi.CreateClient();

            var runner = new GFClientRunner(gfClient);
            runner.Start();

            gfClient.Connection.Aggregate.LoginCompleted += GFClient_OnLoginCompleted;
            gfClient.Connection.Aggregate.LoginFailed += GFClient_OnLoginFailed;
            gfClient.Connection.Aggregate.Disconnected += GFClient_OnDisconnected;
            gfClient.Contracts.Lookup.SymbolLookupReceived += GFClient_OnSymbolLookupReceived;
            gfClient.Subscriptions.Price.PriceTick += GFClient_OnPriceTick;

            gfClient.Connection.Aggregate.Connect(
                new ConnectionContextBuilder()
                    .WithUserName("username")
                    .WithPassword("password")
                    .WithPort(9210)
                    .WithHost("api.gainfutures.com")
                    .WithUUID("9e61a8bc-0a31-4542-ad85-33ebab0e4e86")
                    .WithForceLogin(true)
                    .Build());

            Console.WriteLine("Connecting...");

            _statusTimer = new System.Timers.Timer {Interval = TimeSpan.FromSeconds(10).TotalMilliseconds};
            _statusTimer.Elapsed += (_, __) => StatusTimer_Tick(gfClient);
            _statusTimer.Start();

            Console.WriteLine("Press any key to exit");
            Console.ReadKey();

            gfClient.Connection.Aggregate.Disconnect();
            _statusTimer.Stop();
            runner.Stop();
        }

        private static void GFClient_OnLoginFailed(IGFClient client, LoginFailedEventArgs e)
        {
            Console.WriteLine($"OnLoginFailed: {e.FailReason}");
        }

        private static void GFClient_OnDisconnected(IGFClient client, DisconnectedEventArgs e)
        {
            Console.WriteLine($"OnDisconnected: {e.Message}");
        }

        private static void GFClient_OnLoginCompleted(IGFClient client, LoginCompleteEventArgs e)
        {
            Console.WriteLine($"OnLoginComplete: IsConnected={client.Connection.Aggregate.IsConnected}");
            Console.WriteLine($"\tAccounts: {client.Accounts.Get().Count}, orders: {client.Orders.Get().Count}, base contracts: {client.Contracts.Base.Get().Count}");
            DisplayAccount(client.Accounts.Get().First());
            _frontEsSymbolLookupRequestID = client.Contracts.Lookup.ByCriteria(
                new SymbolLookupRequestBuilder()
                    .WithResultCount(1)
                    .WithSymbol("ES", TextSearchMode.StartsWith)
                    .Build());
        }

        private static void GFClient_OnSymbolLookupReceived(IGFClient client, SymbolLookupEventArgs e)
        {
            if (_frontEsSymbolLookupRequestID != null && e.RequestID == _frontEsSymbolLookupRequestID)
            {
                if (e.Contracts.Count > 0)
                {
                    client.Subscriptions.Price.Subscribe(e.Contracts.First().ID);
                }
            }
        }

        private static void GFClient_OnPriceTick(IGFClient client, PriceChangedEventArgs e)
        {
            // TODO: check price and make a decision to place an order
        }

        private static void StatusTimer_Tick(IGFClient client)
        {
            client.Threading.BeginInvoke(() =>
            {
                if (client.Connection.Aggregate.IsConnected)
                    DisplayAccount(client.Accounts.Get().First());
            });
        }

        private static void DisplayAccount(GF.Api.Accounts.IAccount account)
        {
            Console.WriteLine($"Account: {account.Spec}");
            GF.Api.Balances.IBalance totalBalance = account.TotalBalance;
            Console.WriteLine($"\tNetLiq: {totalBalance.NetLiq:c}");
            Console.WriteLine($"\tCash: {totalBalance.Cash:c}");
            Console.WriteLine($"\tOpen P/L: {totalBalance.OpenPnL:c}");
            Console.WriteLine($"\tTotal P/L: {totalBalance.RealizedPnL + totalBalance.OpenPnL:c}");
            Console.WriteLine($"\tInitial Margin: {totalBalance.InitialMargin:c}");
            var netOptionsValue =
                totalBalance.LongCallOptionsValue
                + totalBalance.LongPutOptionsValue
                + totalBalance.ShortCallOptionsValue
                + totalBalance.ShortPutOptionsValue;
            Console.WriteLine($"\tNet Options Value: {netOptionsValue:c}");
            Console.WriteLine($"Average Positions: {account.AvgPositions.Count}");
        }
    }
}

public class PlaceOrderExample
{
    private static void GFClient_OnPriceTick(IGFClient client, PriceChangedEventArgs e)
    {
        if (Math.Abs(e.Price.LastPrice - e.Price.BidPrice) < e.Contract.TickSize)
            PlaceOrder(client, e.Contract, OrderSide.Buy, e.Price.BidPrice, "By Bid");
        else if (Math.Abs(e.Price.LastPrice - e.Price.AskPrice) < e.Contract.TickSize)
            PlaceOrder(client, e.Contract, OrderSide.Sell, e.Price.AskPrice, "By Ask");
    }

    private static void PlaceOrder(GF.Api.IGFClient client, GF.Api.Contracts.IContract contract, OrderSide orderSide, double limitPrice, string comments)
    {
        if (client.Orders.Get().Count == 0 || client.Orders.Get().Last().IsFinalState)
        {
            OrderDraft orderDraft = new OrderDraftBuilder()
                .WithAccountID(client.Accounts.Get().First().ID)
                .WithContractID(contract.ID)
                .WithSide(orderSide)
                .WithOrderType(OrderType.Limit)
                .WithPrice(limitPrice)
                .WithQuantity(1)
                .WithEnd(DateTime.UtcNow.AddMinutes(1))
                .WithComments(comments)
                .Build();
            IReadOnlyList<OrderDraftValidationError> validationErrors = client.Orders.Drafts.Validate(orderDraft);
            if (validationErrors.Any())
            {
                Console.WriteLine($"ERROR. Order {orderSide} {orderDraft.Quantity} {contract.Symbol} @ {contract.PriceToString(limitPrice)} Limit is invalid:");
                foreach (var error in validationErrors)
                    Console.WriteLine($"\t{error.Message}");
            }
            else
            {
                GF.Api.Orders.IOrder order = client.Orders.SendOrder(orderDraft);
                Console.WriteLine($"Order {order} was sent");
            }
        }
    }
}

private static void StatusTimer_Tick(GF.Api.IGFClient client)
{
    client.Threading.Invoke(() =>
    {
        if (client.Connection.Aggregate.IsConnected)
        {
            DisplayAccount(client.Accounts.Get().First());
            ModifyOrder(client);
        }
    });
}

private static void ModifyOrder(IGFClient client)
{
    if (client.Orders.Get().Any() && !client.Orders.Get().Last().IsFinalState)
    {
        GF.Api.Orders.IOrder currentWorkingOrder = client.Orders.Get().Last();
        if (currentWorkingOrder.Commands.Last().State == CommandState.Executed)
        {
            var priceChange = currentWorkingOrder.IsBuySide
                ? currentWorkingOrder.Contract.TickSize
                : -currentWorkingOrder.Contract.TickSize;
            ModifyOrderDraft modifyOrderDraft = new ModifyOrderDraftBuilder()
                .FromOrder(currentWorkingOrder)
                .WithPrice((currentWorkingOrder.Price ?? 0.0) + priceChange)
                .Build();

            IReadOnlyList<OrderDraftValidationError> validationErrors = client.Orders.Drafts.Validate(modifyOrderDraft);
            if (validationErrors.Any())
            {
                Console.WriteLine($"ERROR. Attempt to modify the order {currentWorkingOrder} failed:");
                foreach (var error in validationErrors)
                    Console.WriteLine($"\t{error.Message}");
            }
            else
            {
                GF.Api.Orders.IOrder order = client.Orders.ModifyOrder(modifyOrderDraft);
                Console.WriteLine($"Modify request has been sent: {order}");
            }
        }
    }
}

private static void StatusTimer_Tick(GF.Api.IGFClient client)
{
    if (client.Connection.Aggregate.IsConnected)
    {
        DisplayAccount(client.Accounts.Get().First());
        CheckAndCancelOrder(client);
        ModifyOrder(client);
    }
}

private static void CheckAndCancelOrder(GF.Api.IGFClient client)
{
    if (client.Orders.Get().Any() && !client.Orders.Get().Last().IsFinalState)
    {
        GF.Api.Orders.IOrder currentWorkingOrder = client.Orders.Get().Last();
        if (currentWorkingOrder.Commands.Last().State == CommandState.Executed)
        {
            if (client.Orders.Drafts.GetPriceCount(currentWorkingOrder.Type) > 0)
            {
                if (Math.Abs((currentWorkingOrder.Price ?? 0.0) - currentWorkingOrder.Contract.CurrentPrice.LastPrice) >= 3 * currentWorkingOrder.Contract.TickSize)
                {
                    Console.WriteLine($"Send request to cancel: {currentWorkingOrder}");
                    client.Orders.CancelOrder(currentWorkingOrder.ID, SubmissionType.Automatic);
                }
            }
        }
    }
}

private static void RegisterOrderStateChanged(GF.Api.IGFClient client)
{
    client.Orders.OrderStateChanged += GFClient_OnOrderStateChanged;
}

private static void GFClient_OnOrderStateChanged(GF.Api.IGFClient client, GF.Api.Orders.OrderStateChangedEventArgs e)
{
    Console.WriteLine($"{e.Order.ID} order state changed from {e.PreviousOrderState} to {e.Order.CurrentState}");
}

private static void RegisterOnOrderConfirmed(GF.Api.IGFClient client)
{
    client.Orders.OrderConfirmed += GFClient_OnOrderConfirmed;
}

private static void GFClient_OnOrderConfirmed(GF.Api.IGFClient client, GF.Api.Orders.OrderConfirmedEventArgs e)
{
    Console.WriteLine($"Order #{e.OriginalOrderID} confirmed. New order ID is {e.Order.ID}");
}

new OrderDraftBuilder()
    .WithOrderType(OrderType.Iceberg)
    .WithIceberg(new IcebergData(1))
    .Build();

new OrderDraftBuilder()
    .WithOrderType(OrderType.TrailingStopLoss)
    .WithTrailingStop(new TrailingStopData(contract.CurrentPrice.LastPrice, (10 - 1) * contract.TickSize))
    .Build();

private static void Main(GF.Api.IGFClient client)
{
    client.Logging.ErrorOccurred += GFClient_OnErrorOccurred;
}

private static void GFClient_OnErrorOccurred(GF.Api.IGFClient client, GF.Api.Utils.ErrorEventArgs e)
{
    Console.WriteLine($"OnError: {e.Exception.Message}");
}

private static void RegisterOnOrderFilled(GF.Api.IGFClient client)
{
    client.Orders.OrderFilled += GFClient_OnOrderFilled;
}

private static void GFClient_OnOrderFilled(GF.Api.IGFClient client, GF.Api.Orders.OrderFilledEventArgs e)
{
    Console.WriteLine(
        "#{0} New fill: {1} @ {2} ({3}). Total filled qty: {4}, avg. price: {5}",
        e.Order.ID,
        e.Fill.Quantity,
        e.Fill.Contract.PriceToString(e.Fill.Price),
        e.Fill.IsActive ? "active" : "cancelled",
        e.Order.Fills.TotalQuantity,
        e.Order.Contract.PriceToString(e.Order.Fills.AvgPrice));
}

private static void RegisterOnAvgPositionChanged(GF.Api.IGFClient client)
{
    client.Accounts.AvgPositionChanged += GFClient_OnAvgPositionChanged;
}

private static void GFClient_OnAvgPositionChanged(GF.Api.IGFClient client, GF.Api.Positions.PositionChangedEventArgs e)
{
    Console.WriteLine(
        "Average Position. {0}/{1}: Net Pos: {2} @ {3}, Bought: {4}, Sold {5}, Prev Pos: {6} P/L: {7:c}",
        e.Account.Spec, e.ContractPosition.Contract.Symbol,
        e.ContractPosition.Net.Volume, e.ContractPosition.Net.Price,
        e.ContractPosition.Long.Volume, e.ContractPosition.Short.Volume,
        e.ContractPosition.Prev.Volume,
        e.ContractPosition.OTE + e.ContractPosition.Gain);
}

private static void RegisterOnBalanceChanged(GF.Api.IGFClient client)
{
    client.Accounts.AccountSummaryChanged += GFClient_OnAccountSummaryChanged;
    client.Accounts.BalanceChanged += GFClient_OnBalanceChanged;
}

private static void GFClient_OnAccountSummaryChanged(GF.Api.IGFClient client, GF.Api.Accounts.AccountSummaryChangedEventArgs e)
{
    DisplayBalance("Account Summary Changed", e.Account, e.Currency);
}

private static void GFClient_OnBalanceChanged(GF.Api.IGFClient client, GF.Api.Accounts.BalanceChangedEventArgs e)
{
    DisplayBalance("Balance Changed", e.Account, e.Currency);
}

private static void DisplayBalance(string comment, GF.Api.Accounts.IAccount account, GF.Api.Currencies.ICurrency currency)
{
    GF.Api.Balances.IBalance balance = account.Balances[currency];
    Console.WriteLine($"{comment}. {account.Spec} ({currency.Name}): P/L = {Math.Round(balance.OpenPnL + balance.RealizedPnL, 2)}. Total Net Liq: {account.TotalBalance.NetLiq:c}");
}