using AssortHelpers.Common.Helpers;
using AssortHelpers.Helpers;
using AssortUpdater;
using AssortValidator.Common.Helpers;
using static AssortUpdater.AssortFlattener;

class Program
{
    static void Main(string[] args)
    {
        var inputPath = CreateWorkingFolders();
        InputFileHelper.SetInputFiles(inputPath);

        var existingAssortData = AssortHelper.GetAssortData();
        var liveAssortData = AssortHelper.GetLiveAssortData();

        var questData = QuestHelper.GetQuestData("quests");
        var questAssortData = QuestHelper.GetQuestAssortUnlocks(questData.Values.ToList());

        foreach (var trader in liveAssortData)
        {
            var traderId = TraderHelper.GetTraderIdByName(trader.Key);
            var traderQuests = questData.Where(x=>x.Value.traderId == traderId);
            var traderAssortData = questAssortData.Where(x => x.TraderId == traderId);

            var liveAssorts = trader.Value;
            var existingAssorts = existingAssortData[trader.Key];
            var mergedAssortData = liveAssorts;

            var flattenedLiveAssorts = AssortFlattener.FlattenLiveAssorts(liveAssorts);
            var flattenedExistingAssorts = AssortFlattener.FlattenExistingAssorts(existingAssorts);

            //LogItemsMissingInLiveAssorts(trader.Key.ToString(), flattenedExistingAssorts, flattenedLiveAssorts);

            //LogItemsMissingInExistingAssorts(trader.Key.ToString(), flattenedExistingAssorts, flattenedLiveAssorts);


            var result = CreateMergedFlattenedAssorts(trader.Key.ToString(), flattenedLiveAssorts, flattenedExistingAssorts);


            // generate trader specific assort quest data, write out to file
            var questAssorts = QuestHelper.CreateQuestAssortsList(traderAssortData);
            //JsonWriter.WriteJson(questAssorts, traderId, Directory.GetCurrentDirectory(), "questassort");
        }
    }

    private static List<FlatAssort> CreateMergedFlattenedAssorts(string trader, List<FlatAssort> flattenedLiveAssorts, List<FlatAssort> flattenedExistingAssorts)
    {
        var completeAssorts = new List<FlatAssort>();

        // Add live assorts
        foreach (var liveAssort in flattenedLiveAssorts)
        {
            completeAssorts.Add(liveAssort);
        }
        LoggingHelpers.LogSuccess($"{trader} Added {flattenedLiveAssorts.Count} items from live");


        // Check for missing existing assorts and add those
        var ExistingItemCount = 0;
        foreach (var existingAssort in flattenedExistingAssorts)
        {
            var matchInCompleteAssorts = GetMatchingAssortFromCompleteList(trader, existingAssort, completeAssorts);
            if (matchInCompleteAssorts is null)
            {
                // no assort found, add
                LoggingHelpers.LogWarning($"{trader} Adding Item found in existing assorts but not live: {existingAssort.ItemId} {existingAssort.ItemName} Level: {existingAssort.Level}");
                completeAssorts.Add(existingAssort);
                ExistingItemCount++;
            }
        }

        LoggingHelpers.LogSuccess($"{trader} Added {ExistingItemCount} existing items");
        return completeAssorts;
    }

    private static FlatAssort GetMatchingAssortFromCompleteList(string traderName, FlatAssort assortToFind, List<FlatAssort> completeAssorts)
    {
        var existingAssort = completeAssorts.Where(x => x.ItemId == assortToFind.ItemId
                                                      && x.Level == assortToFind.Level);

        // check only one item found
        if (existingAssort?.Count() == 1)
        {
            //LoggingHelpers.LogSuccess($"{traderName} match found for item: {assortToFind.ItemId} {assortToFind.ItemName} Level: {assortToFind.Level}");
            return existingAssort.First();
        }

        if (existingAssort?.Count() > 1)
        {
            // try and get it by money
            existingAssort = completeAssorts.Where( x=> x.ItemId == assortToFind.ItemId
                                                    && x.Level == assortToFind.Level
                                                    && x.IsMoney == assortToFind.IsMoney);

            if (existingAssort?.Count() == 1)
            {
                return existingAssort.First();
            }
            if (existingAssort?.Count() > 1)
            {
                existingAssort = completeAssorts.Where(x => x.ItemId == assortToFind.ItemId
                                                   && x.Level == assortToFind.Level
                                                   && x.IsMoney == assortToFind.IsMoney
                                                   && x.SubItems.Count == assortToFind.SubItems.Count
                                                   && x.BarterDetails[0].count == assortToFind.BarterDetails[0].count);

                if ( existingAssort?.Count() == 1)
                {
                    return existingAssort.First();
                }
            }
            }

        //LoggingHelpers.LogError($"{traderName} No match found for item: {assortToFind.ItemId} {assortToFind.ItemName} Level: {assortToFind.Level}");
        return null;
    }

    private static void LogItemsMissingInExistingAssorts(string traderName, List<AssortFlattener.FlatAssort> flattenedExistingAssorts, List<AssortFlattener.FlatAssort> flattenedLiveAssorts)
    {
        foreach (var liveAssort in flattenedLiveAssorts)
        {
            // get live assort, match by level and item tpl
            var existingAssort = flattenedExistingAssorts.Where(x => x.ItemId == liveAssort.ItemId && x.Level == liveAssort.Level);

            if (existingAssort.Count() > 1)
            {
                // we have multiple matches, lets compare by number of rewards
                existingAssort = flattenedExistingAssorts.Where(x => x.ItemId == liveAssort.ItemId
                && x.Level == liveAssort.Level
                && x.BarterDetails.Count == liveAssort.BarterDetails.Count
                && x.SubItems.Count == liveAssort.SubItems.Count
                && x.IsMoney == liveAssort.IsMoney);
                if (existingAssort is null)
                {
                    LoggingHelpers.LogError($"{traderName} multiple matches found for item: {liveAssort.ItemId} {liveAssort.ItemName} Level: {liveAssort.Level}");
                    continue;
                }
            }

            if (liveAssort is null)
            {
                LoggingHelpers.LogError($"{traderName} unable to find matching live assort for item: {liveAssort.ItemId} {liveAssort.ItemName} Level: {liveAssort.Level}");
            }
            else
            {
                LoggingHelpers.LogSuccess($"{traderName} found matching live assort for item: {liveAssort.ItemId} {liveAssort.ItemName} Level: {liveAssort.Level}");
            }
        }
    }

    private static void LogItemsMissingInLiveAssorts(string traderName, List<AssortFlattener.FlatAssort> flattenedExistingAssorts, List<AssortFlattener.FlatAssort> flattenedLiveAssorts)
    {
        foreach (var existingAssort in flattenedExistingAssorts)
        {
            // get live assort, match by level and item tpl
            var liveAssort = flattenedLiveAssorts.Where(x => x.ItemId == existingAssort.ItemId && x.Level == existingAssort.Level);

            if (liveAssort.Count() > 1)
            {
                // we have multiple matches, lets compare by number of rewards
                liveAssort = flattenedLiveAssorts.Where(x => x.ItemId == existingAssort.ItemId
                                                        && x.Level == existingAssort.Level
                                                        && x.BarterDetails.Count == existingAssort.BarterDetails.Count
                                                        && x.SubItems.Count == existingAssort.SubItems.Count
                                                        && x.IsMoney == existingAssort.IsMoney);
                if (liveAssort.Count() > 1)
                {
                    LoggingHelpers.LogError($"{traderName} multiple matches found for item: {existingAssort.ItemId} {existingAssort.ItemName} Level: {existingAssort.Level}");
                    continue;
                }
            }

            if (liveAssort is null)
            {
                LoggingHelpers.LogError($"{traderName} unable to find matching existing assort for item: {existingAssort.ItemId} {existingAssort.ItemName} Level: {existingAssort.Level}");
            }
            else
            {
                LoggingHelpers.LogSuccess($"{traderName} found matching existing assort for item: {existingAssort.ItemId} {existingAssort.ItemName} Level: {existingAssort.Level}");
            }
        }
    }

    private static string CreateWorkingFolders()
    {
        var workingPath = Directory.GetCurrentDirectory();
        // create input folder
        var inputPath = $"{workingPath}//input";
        DiskHelpers.CreateDirIfDoesntExist(inputPath);

        return inputPath;
    }
}