// EDDN Schema reference: https://github.com/EDSM-NET/EDDN/blob/master/schemas/commodity-v3.0.json

/// <summary> This class is designed to be deserialized from market.json or from the Frontier API.

/// This class is designed to be serialized and passed to the commodity schema on EDDN. </summary>

public class MarketInfoItem

{

[JsonProperty("name")]

public string edName

{

get => _edName;

set => _edName = value.ToLowerInvariant()

.Replace("$", "")

.Replace("_name;", "");

}

[JsonIgnore]

private string _edName;

// Station prices

[JsonProperty, JsonConverter(typeof(DecimalToIntPriceConverter))]

public int buyPrice { get; set; }

[JsonProperty, JsonConverter(typeof(DecimalToIntPriceConverter))]

public int meanPrice { get; set; }

[JsonProperty, JsonConverter(typeof(DecimalToIntPriceConverter))]

public int sellPrice { get; set; }

// Station in-stock parameter

[JsonProperty]

public int stock

{

get => _stock;

set

{

if (value > 0)

{

statusFlags.Add("Producer");

}

_stock = value;

}

}

[JsonIgnore]

private int _stock;

[JsonConverter(typeof(NullableCommodityBracketConverter))]

[JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate, NullValueHandling = NullValueHandling.Include)]

public CommodityBracket? stockBracket { get; set; } // Possible values are 0, 1, 2, 3, or "" so we use an optional enum

// Station in-demand parameters

[JsonProperty]

public int demand

{

get => _demand;

set

{

if (value > 1)

{

statusFlags.Add("Consumer");

}

_demand = value;

}

}

[JsonIgnore]

private int _demand;

[JsonConverter(typeof(NullableCommodityBracketConverter))]

[JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate, NullValueHandling = NullValueHandling.Include)]

public CommodityBracket? demandBracket { get; set; } // Possible values are 0, 1, 2, 3, or "" so we use an optional enum

// Implement conditional property serialization for select properties (ref. https://www.newtonsoft.com/json/help/html/ConditionalProperties.htm)

// This allows properties to be deserialized to the class but not serialized to EDDN.

[JsonProperty("id")]

public long EliteID { get; set; }

public static bool ShouldSerializeEliteID () => false;

// The EDDN schema does not currently permit category.

[JsonProperty]

public string category

{

get => _category;

set => _category = value.ToLowerInvariant()

.Replace("$market_category", "")

.Replace("_", "")

.Replace(";", "");

}

[JsonIgnore]

private string _category;

// The Frontier API uses `categoryName` rather than `category`, we normalize that here.

[JsonProperty] // As a private property, it can be deserialized but shall not be serialized to EDDN.

private protected string categoryName { set => category = value; }

public static bool ShouldSerializecategory () => false;

[JsonProperty]

public bool rare

{

get => _rare;

set

{

if (value)

{

statusFlags.Add("Rare");

}

_rare = value;

}

}

[JsonIgnore]

private bool _rare;

public static bool ShouldSerializerare() => false;

[JsonProperty]

public HashSet<string> statusFlags { get; set; } = [ ];

public bool ShouldSerializestatusFlags()

{

// Don't serialize status flags if they are empty as the schema requires that if present they contain at least 1 element

return statusFlags != null && statusFlags.Count > 0;

}

public bool IsMarketable()

{

// Don't serialize non-marketable commodities such as drones / limpets

if ( string.Equals( category.Replace( "-", "" ), "nonmarketable", StringComparison.OrdinalIgnoreCase ) ||

string.Equals( edName, "drones", StringComparison.OrdinalIgnoreCase ) )

{

return false;

}

return true;

}

public MarketInfoItem()

{ }

public MarketInfoItem(long eliteId, string Name, string Category, int BuyPrice, int SellPrice, int MeanPrice, CommodityBracket? StockBracket, CommodityBracket? DemandBracket, int Stock, int Demand, bool Rare = false, HashSet<string> statusFlags = null)

{

this.EliteID = eliteId;

this.edName = Name;

this.category = Category;

this.buyPrice = BuyPrice;

this.sellPrice = SellPrice;

this.meanPrice = MeanPrice;

this.stockBracket = StockBracket;

this.demandBracket = DemandBracket;

this.stock = Stock;

this.demand = Demand;

this.rare = Rare;

this.statusFlags = statusFlags ?? this.statusFlags;

}

public CommodityMarketQuote ToCommodityMarketQuote()

{

try

{

Logging.Debug($"Converting MarketInfoItem to CommodityMarketQuote: ", this);

var definition = CommodityDefinition.CommodityDefinitionFromEliteID(EliteID, edName) ?? CommodityDefinition.FromEDName(edName);

if (!string.Equals( edName, definition?.edname, StringComparison.OrdinalIgnoreCase ) )

{

// Unknown or obsolete commodity definition; report the full object so that we can update the definitions

Logging.Info("Commodity definition error: " + edName, JsonConvert.SerializeObject(this));

}

definition ??= new CommodityDefinition(EliteID, edName, CommodityCategory.FromEDName(category), meanPrice);

var quote = new CommodityMarketQuote(definition)

{

avgprice = meanPrice,

buyprice = buyPrice,

stock = stock,

stockbracket = stockBracket,

sellprice = sellPrice,

demand = demand,

demandbracket = demandBracket,

StatusFlags = statusFlags

};

return quote;

}

catch (Exception ex)

{

Logging.Error($"Failed to parse OutfittingInfoItem.", ex);

}

return null;

}

}

public class NullableCommodityBracketConverter : JsonConverter

{

public override bool CanConvert(Type objectType)

{

return objectType == typeof(CommodityBracket?);

}

public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

{

throw new NotImplementedException();

}

public override bool CanRead => false;

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

{

if (value == null)

{

serializer.Serialize(writer, "");

}

else if (value is string s)

{

serializer.Serialize(writer, s);

}

else if (value is CommodityBracket bracket)

{

serializer.Serialize(writer, bracket);

}

}

}

// Prices are sometimes written as floats (either to Market.json or to the Frontier API).

// These must be converted to integers before they can be passed to EDDN.

class DecimalToIntPriceConverter : JsonConverter

{

public override bool CanConvert(Type objectType)

{

return (objectType == typeof(decimal) || objectType == typeof(decimal?));

}

public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

{

var token = JToken.Load(reader);

if (token.Type is JTokenType.Float or JTokenType.Integer)

{

return token.ToObject<int>();

}

if (token.Type == JTokenType.Null)

{

return null;

}

throw new JsonSerializationException("Unexpected token type: " +

token.Type.ToString());

}

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

{

if (value is null)

{

serializer.Serialize(writer, null);

}

else if (value is int i)

{

serializer.Serialize(writer, i);

}

else if (value is decimal d)

{

serializer.Serialize(writer, Convert.ToInt32(d));

}

}

}