edjournal/MissionCompletedEntry.cs

using System.Collections.Generic;
using System.Text;
using System.Linq;
using Newtonsoft.Json.Linq;

namespace EDJournal {
    public class MissionCompletedEntry : Entry {
        private Dictionary<string, Dictionary<ulong, string>> influences = new Dictionary<string, Dictionary<ulong, string>>();
        private List<string> affected = new List<string>();
        private string readable_name = null;
        private bool readable_name_generated = false;

        public Dictionary<string, Dictionary<ulong, string>> Influences => influences;

        protected override void Initialise() {
            MissionID = JSON.Value<int?>("MissionID") ?? 0;
            Name = JSON.Value<string>("Name");
            Faction = JSON.Value<string>("Faction") ?? "";
            TargetFaction = JSON.Value<string>("TargetFaction") ?? "";
            if (JSON.ContainsKey("Commodity_Localised")) {
                Commodity = JSON.Value<string>("Commodity_Localised");
            }
            if (JSON.ContainsKey("Count")) {
                Count = JSON.Value<int>("Count");
            }
            if (JSON.ContainsKey("Donated")) {
                Donated = JSON.Value<int>("Donated");
            }

            MakeHumanReadableName();
            BuildInfluenceList();
        }

        private void BuildInfluenceList() {
            influences.Clear();
            affected.Clear();

            var effects = JSON.Value<JArray>("FactionEffects");
            foreach (var effect in effects.Children<JObject>()) {
                string faction = effect.Value<string>("Faction");
                affected.Add(faction);

                var influence = effect.Value<JArray>("Influence");
                if (influence == null || influence.Count == 0) {
                    // No influence reward, happens sometimes, but we have to accept it
                    influences.Add(faction, new Dictionary<ulong, string>());
                } else {
                    foreach (var infl in influence.Children<JObject>()) {
                        infl.TryGetValue("Influence", out JToken result);
                        infl.TryGetValue("SystemAddress", out JToken systemaddr);
                        if (result != null && result.Type == JTokenType.String &&
                            systemaddr != null && systemaddr.Type == JTokenType.Integer) {
                            ulong system = systemaddr.ToObject<ulong?>() ?? 0;
                            string inf = result.ToString();

                            if (!influences.ContainsKey(faction)) {
                                influences.Add(faction, new Dictionary<ulong, string>());
                            }

                            if (!influences[faction].ContainsKey(system)) {
                                influences[faction].Add(system, inf);
                            }
                        }
                    }
                }
            }
        }

        public string Name { get; set; }
        public string Commodity { get; set; }
        public int Count { get; set; }
        public int Donated { get; set; }
        public int MissionID { get; set; }
        public string Faction { get; set; }
        public string TargetFaction { get; set; }

        private void MakeHumanReadableName() {
            if (readable_name != null || Name == null) {
                return;
            }

            string readable = HumanReadableMissionName.MakeHumanReadableName(Name);
            StringBuilder builder = new StringBuilder();

            if (readable == null) {
                builder = new StringBuilder(Name);
                builder.Replace("Mission_", "");
                builder.Replace("_name", "");
                builder.Replace("_MB", "");
                builder.Replace('_', ' ');
                builder.Replace("Illegal", " (Illegal)");
                builder.Replace("OnFoot", "On Foot");
                builder.Replace(" BS", "");
                builder.Replace("HackMegaship", "Hack Megaship");
                builder.Replace("Boom", "");
                builder.Replace("RebootRestore", "Reboot/Restore");
                builder.Replace("CivilLiberty", "");
                readable_name_generated = true;
            } else {
                builder.Append(readable);
            }

            if (Count > 0 && Commodity != null) {
                builder.AppendFormat(" ({0} {1})", Count, Commodity);
            }

            if (Donated > 0) {
                builder.AppendFormat(" ({0})", Credits.FormatCredits(Donated));
            }

            readable_name = builder.ToString().Trim();
        }

        public string HumanReadableName {
            get {
                MakeHumanReadableName();
                return readable_name;
            }
        }

        public bool HumanReadableNameWasGenerated {
            get {
                MakeHumanReadableName();
                return readable_name_generated;
            }
        }

        public string[] AffectedFactions => affected.ToArray();

        public string GetInfluenceForFaction(string faction) {
            if (!influences.ContainsKey(faction)) {
                return "";
            }

            var inf = influences[faction];
            return string.Join("", inf.Values);
        }

        public string GetInfluenceForFaction(string faction, ulong systemaddr) {
            if (!influences.ContainsKey(faction)) {
                return "";
            }

            if (!influences[faction].ContainsKey(systemaddr)) {
                return "";
            }

            return influences[faction][systemaddr];
        }
    }
}