/*
 * This file is part of Applied Energistics 2.
 * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved.
 *
 * Applied Energistics 2 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Applied Energistics 2 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
 */

package appeng.me.cache;

import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;

import appeng.api.config.AccessRestriction;
import appeng.api.config.Actionable;
import appeng.api.networking.IControllerCache;
import appeng.api.networking.IGrid;
import appeng.api.networking.IGridHost;
import appeng.api.networking.IGridNode;
import appeng.api.networking.IGridStorage;
import appeng.api.networking.crafting.*;
import appeng.api.networking.energy.IEnergyGrid;
import appeng.api.networking.events.MENetworkCraftingCpuChange;
import appeng.api.networking.events.MENetworkCraftingPatternChange;
import appeng.api.networking.events.MENetworkEventSubscribe;
import appeng.api.networking.events.MENetworkPostCacheConstruction;
import appeng.api.networking.security.BaseActionSource;
import appeng.api.networking.storage.IStorageGrid;
import appeng.api.storage.ICellProvider;
import appeng.api.storage.IMEInventoryHandler;
import appeng.api.storage.StorageChannel;
import appeng.api.storage.data.IAEItemStack;
import appeng.api.storage.data.IAEStack;
import appeng.api.storage.data.IItemList;
import appeng.crafting.CraftingJob;
import appeng.crafting.CraftingLink;
import appeng.crafting.CraftingLinkNexus;
import appeng.crafting.CraftingWatcher;
import appeng.me.helpers.GenericInterestManager;
import appeng.tile.crafting.TileCraftingStorageTile;
import appeng.tile.crafting.TileCraftingTile;
import appeng.tile.legacy.TileLegacyController;
import appeng.util.ItemSorters;
import com.google.common.collect.*;
import net.minecraft.world.World;

public class CraftingGridCache implements ICraftingGrid, ICraftingProviderHelper,
                                          ICellProvider, IMEInventoryHandler<IAEStack> {
    private static final ExecutorService CRAFTING_POOL;
    private static final Comparator<ICraftingPatternDetails> COMPARATOR
        = new Comparator<ICraftingPatternDetails>() {
              @Override
              public int compare(
                  final ICraftingPatternDetails firstDetail,
                  final ICraftingPatternDetails nextDetail
              ) {
                  return nextDetail.getPriority() - firstDetail.getPriority();
              }
          };

    static {
        final ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(final Runnable ar) {
                return new Thread(ar, "AE Crafting Calculator");
            }
        };

        CRAFTING_POOL = Executors.newCachedThreadPool(factory);
    }

    private final Set<ICraftingCPU> craftingCPUs
        = new HashSet<ICraftingCPU>();
    private final Set<ICraftingProvider> craftingProviders
        = new HashSet<ICraftingProvider>();
    private final Map<IGridNode, ICraftingWatcher> craftingWatchers
        = new HashMap<IGridNode, ICraftingWatcher>();
    private final IGrid grid;
    private final Map<ICraftingPatternDetails, List<ICraftingMedium>> craftingMethods
        = new HashMap<ICraftingPatternDetails, List<ICraftingMedium>>();
    private final Map<IAEItemStack, ImmutableList<ICraftingPatternDetails>> craftableItems
        = new HashMap<IAEItemStack, ImmutableList<ICraftingPatternDetails>>();
    private final Set<IAEItemStack> emitableItems = new HashSet<IAEItemStack>();
    private final Map<String, CraftingLinkNexus> craftingLinks
        = new HashMap<String, CraftingLinkNexus>();
    private final Multimap<IAEStack, CraftingWatcher> interests = HashMultimap.create();
    private final GenericInterestManager<CraftingWatcher> interestManager
        = new GenericInterestManager<CraftingWatcher>(this.interests);
    private IStorageGrid storageGrid;
    private IEnergyGrid energyGrid;
    private boolean updateList = false;

    public CraftingGridCache(final IGrid grid) {
        this.grid = grid;
    }

    @MENetworkEventSubscribe
    public void
    afterCacheConstruction(final MENetworkPostCacheConstruction cacheConstruction) {
        this.storageGrid = this.grid.getCache(IStorageGrid.class);
        this.energyGrid = this.grid.getCache(IEnergyGrid.class);

        this.storageGrid.registerCellProvider(this);
    }

    @Override
    public void onUpdateTick() {
        if (this.updateList) {
            this.updateList = false;
            this.updateCPUClusters();
        }

        final Iterator<CraftingLinkNexus> craftingLinkIterator
            = this.craftingLinks.values().iterator();
        while (craftingLinkIterator.hasNext()) {
            if (craftingLinkIterator.next().isDead(this.grid, this)) {
                craftingLinkIterator.remove();
            }
        }

        for (final ICraftingCPU cpu : this.craftingCPUs) {
            cpu.updateCraftingLogic(this.grid, this.energyGrid, this);
        }
    }

    @Override
    public void removeNode(final IGridNode gridNode, final IGridHost machine) {
        if (machine instanceof ICraftingWatcherHost) {
            final ICraftingWatcher craftingWatcher = this.craftingWatchers.get(machine);
            if (craftingWatcher != null) {
                craftingWatcher.clear();
                this.craftingWatchers.remove(machine);
            }
        }

        if (machine instanceof ICraftingRequester) {
            for (final CraftingLinkNexus link : this.craftingLinks.values()) {
                if (link.isMachine(machine)) {
                    link.removeNode();
                }
            }
        }

        if (machine instanceof TileCraftingTile) {
            this.updateList = true;
        }

        if (machine instanceof ICraftingProvider) {
            this.craftingProviders.remove(machine);
            this.updatePatterns();
        }
    }

    @Override
    public void addNode(final IGridNode gridNode, final IGridHost machine) {
        if (machine instanceof ICraftingWatcherHost) {
            final ICraftingWatcherHost watcherHost = (ICraftingWatcherHost) machine;
            final CraftingWatcher watcher = new CraftingWatcher(this, watcherHost);
            this.craftingWatchers.put(gridNode, watcher);
            watcherHost.updateWatcher(watcher);
        }

        if (machine instanceof ICraftingRequester) {
            for (final ICraftingLink link :
                 ((ICraftingRequester) machine).getRequestedJobs()) {
                if (link instanceof CraftingLink) {
                    this.addLink((CraftingLink) link);
                }
            }
        }

        if (machine instanceof TileCraftingTile || machine instanceof TileLegacyController) {
            this.updateList = true;
        }

        if (machine instanceof ICraftingProvider) {
            this.craftingProviders.add((ICraftingProvider) machine);
            this.updatePatterns();
        }
    }

    @Override
    public void onSplit(final IGridStorage destinationStorage) { // nothing!
    }

    @Override
    public void onJoin(final IGridStorage sourceStorage) {
        // nothing!
    }

    @Override
    public void populateGridStorage(final IGridStorage destinationStorage) {
        // nothing!
    }

    private void updatePatterns() {
        final Map<IAEItemStack, ImmutableList<ICraftingPatternDetails>> oldItems
            = this.craftableItems;

        // erase list.
        this.craftingMethods.clear();
        this.craftableItems.clear();
        this.emitableItems.clear();

        // update the stuff that was in the list...
        this.storageGrid.postAlterationOfStoredItems(
            StorageChannel.ITEMS, oldItems.keySet(), new BaseActionSource()
        );

        // re-create list..
        for (final ICraftingProvider provider : this.craftingProviders) {
            provider.provideCrafting(this);
        }

        final Map<IAEItemStack, Set<ICraftingPatternDetails>> tmpCraft
            = new HashMap<IAEItemStack, Set<ICraftingPatternDetails>>();

        // new craftables!
        for (final ICraftingPatternDetails details : this.craftingMethods.keySet()) {
            for (IAEItemStack out : details.getOutputs()) {
                out = out.copy();
                out.reset();
                out.setCraftable(true);

                Set<ICraftingPatternDetails> methods = tmpCraft.get(out);

                if (methods == null) {
                    tmpCraft.put(
                        out, methods = new TreeSet<ICraftingPatternDetails>(COMPARATOR)
                    );
                }

                methods.add(details);
            }
        }

        // make them immutable
        for (final Entry<IAEItemStack, Set<ICraftingPatternDetails>> e :
             tmpCraft.entrySet()) {
            this.craftableItems.put(e.getKey(), ImmutableList.copyOf(e.getValue()));
        }

        this.storageGrid.postAlterationOfStoredItems(
            StorageChannel.ITEMS, this.craftableItems.keySet(), new BaseActionSource()
        );
    }

    private void updateCPUClusters() {
        this.craftingCPUs.clear();
        IControllerCache cc = this.grid.getCache(IControllerCache.class);
        craftingCPUs.addAll(cc.getCPUs());

        for (final IGridNode cst : this.grid.getMachines(TileCraftingStorageTile.class)) {
            final TileCraftingStorageTile tile
                = (TileCraftingStorageTile) cst.getMachine();
            final ICraftingCPU cluster = (ICraftingCPU) tile.getCluster();
            if (cluster != null) {
                this.craftingCPUs.add(cluster);

                if (cluster.getLastCraftingLink() != null) {
                    this.addLink((CraftingLink) cluster.getLastCraftingLink());
                }
            }
        }
    }

    public void addLink(final CraftingLink link) {
        if (link.isStandalone()) {
            return;
        }

        CraftingLinkNexus nexus = this.craftingLinks.get(link.getCraftingID());
        if (nexus == null) {
            this.craftingLinks.put(
                link.getCraftingID(), nexus = new CraftingLinkNexus(link.getCraftingID())
            );
        }

        link.setNexus(nexus);
    }

    @MENetworkEventSubscribe
    public void updateCPUClusters(final MENetworkCraftingCpuChange c) {
        this.updateList = true;
    }

    @MENetworkEventSubscribe
    public void updateCPUClusters(final MENetworkCraftingPatternChange c) {
        this.updatePatterns();
    }

    @Override
    public void
    addCraftingOption(final ICraftingMedium medium, final ICraftingPatternDetails api) {
        List<ICraftingMedium> details = this.craftingMethods.get(api);
        if (details == null) {
            details = new ArrayList<ICraftingMedium>();
            details.add(medium);
            this.craftingMethods.put(api, details);
        } else {
            details.add(medium);
        }
    }

    @Override
    public void setEmitable(final IAEItemStack someItem) {
        this.emitableItems.add(someItem.copy());
    }

    @Override
    public List<IMEInventoryHandler> getCellArray(final StorageChannel channel) {
        final List<IMEInventoryHandler> list = new ArrayList<IMEInventoryHandler>(1);

        if (channel == StorageChannel.ITEMS) {
            list.add(this);
        }

        return list;
    }

    @Override
    public int getPriority() {
        return Integer.MAX_VALUE;
    }

    @Override
    public AccessRestriction getAccess() {
        return AccessRestriction.WRITE;
    }

    @Override
    public boolean isPrioritized(final IAEStack input) {
        return true;
    }

    @Override
    public boolean canAccept(final IAEStack input) {
        for (final ICraftingCPU cpu : this.craftingCPUs) {
            if (cpu.canAccept(input)) {
                return true;
            }
        }

        return false;
    }

    @Override
    public int getSlot() {
        return 0;
    }

    @Override
    public boolean validForPass(final int i) {
        return i == 1;
    }

    @Override
    public IAEStack
    injectItems(IAEStack input, final Actionable type, final BaseActionSource src) {
        for (final ICraftingCPU cpu : this.craftingCPUs) {
            input = cpu.injectItems(input, type, src);
        }

        return input;
    }

    @Override
    public IAEStack extractItems(
        final IAEStack request, final Actionable mode, final BaseActionSource src
    ) {
        return null;
    }

    @Override
    public IItemList<IAEStack> getAvailableItems(final IItemList<IAEStack> out) {
        // add craftable items!
        for (final IAEItemStack stack : this.craftableItems.keySet()) {
            out.addCrafting(stack);
        }

        for (final IAEItemStack st : this.emitableItems) {
            out.addCrafting(st);
        }

        return out;
    }

    @Override
    public StorageChannel getChannel() {
        return StorageChannel.ITEMS;
    }

    @Override
    public ImmutableCollection<ICraftingPatternDetails> getCraftingFor(
        final IAEItemStack whatToCraft,
        final ICraftingPatternDetails details,
        final int slotIndex,
        final World world
    ) {
        final ImmutableList<ICraftingPatternDetails> res
            = this.craftableItems.get(whatToCraft);

        if (res == null) {
            if (details != null && details.isCraftable()) {
                for (final IAEItemStack ais : this.craftableItems.keySet()) {
                    if (ais.getItem() == whatToCraft.getItem()
                        && (!ais.getItem().getHasSubtypes()
                            || ais.getItemDamage() == whatToCraft.getItemDamage())) {
                        if (details.isValidItemForSlot(
                                slotIndex, ais.getItemStack(), world
                            )) {
                            return this.craftableItems.get(ais);
                        }
                    }
                }
            }

            return ImmutableSet.of();
        }

        return res;
    }

    @Override
    public Future<ICraftingJob> beginCraftingJob(
        final World world,
        final IGrid grid,
        final BaseActionSource actionSrc,
        final IAEItemStack slotItem,
        final ICraftingCallback cb
    ) {
        if (world == null || grid == null || actionSrc == null || slotItem == null) {
            throw new IllegalArgumentException("Invalid Crafting Job Request");
        }

        final CraftingJob job = new CraftingJob(world, grid, actionSrc, slotItem, cb);

        return CRAFTING_POOL.submit(job, (ICraftingJob) job);
    }

    @Override
    public ICraftingLink submitJob(
        final ICraftingJob job,
        final ICraftingRequester requestingMachine,
        final ICraftingCPU target,
        final boolean prioritizePower,
        final BaseActionSource src
    ) {
        if (job.isSimulation()) {
            return null;
        }

        ICraftingCPU cpuCluster = null;

        if (target instanceof ICraftingCPU) {
            cpuCluster = (ICraftingCPU) target;
        }

        if (target == null) {
            final List<ICraftingCPU> validCpusClusters
                = new ArrayList<ICraftingCPU>();
            for (final ICraftingCPU cpu : this.craftingCPUs) {
                if (cpu.isActive() && !cpu.isBusy()
                    && cpu.getAvailableStorage() >= job.getByteTotal()) {
                    validCpusClusters.add(cpu);
                }
            }

            Collections.sort(validCpusClusters, new Comparator<ICraftingCPU>() {
                @Override
                public int compare(
                    final ICraftingCPU firstCluster,
                    final ICraftingCPU nextCluster
                ) {
                    if (prioritizePower) {
                        final int comparison = ItemSorters.compareLong(
                            nextCluster.getCoProcessors(), firstCluster.getCoProcessors()
                        );
                        if (comparison != 0) {
                            return comparison;
                        }
                        return ItemSorters.compareLong(
                            nextCluster.getAvailableStorage(),
                            firstCluster.getAvailableStorage()
                        );
                    }

                    final int comparison = ItemSorters.compareLong(
                        firstCluster.getCoProcessors(), nextCluster.getCoProcessors()
                    );
                    if (comparison != 0) {
                        return comparison;
                    }
                    return ItemSorters.compareLong(
                        firstCluster.getAvailableStorage(),
                        nextCluster.getAvailableStorage()
                    );
                }
            });

            if (!validCpusClusters.isEmpty()) {
                cpuCluster = validCpusClusters.get(0);
            }
        }

        if (cpuCluster != null) {
            return cpuCluster.submitJob(this.grid, job, src, requestingMachine);
        }

        return null;
    }

    @Override
    public ImmutableSet<ICraftingCPU> getCpus() {
        return ImmutableSet.copyOf(new ActiveCpuIterator(this.craftingCPUs));
    }

    @Override
    public boolean canEmitFor(final IAEItemStack someItem) {
        return this.emitableItems.contains(someItem);
    }

    @Override
    public boolean isRequesting(final IAEItemStack what) {
        for (final ICraftingCPU cluster : this.craftingCPUs) {
            if (cluster.isMaking(what)) {
                return true;
            }
        }

        return false;
    }

    public List<ICraftingMedium> getMediums(final ICraftingPatternDetails key) {
        List<ICraftingMedium> mediums = this.craftingMethods.get(key);

        if (mediums == null) {
            mediums = ImmutableList.of();
        }

        return mediums;
    }

    public boolean hasCpu(final ICraftingCPU cpu) {
        return this.craftingCPUs.contains(cpu);
    }

    public GenericInterestManager<CraftingWatcher> getInterestManager() {
        return this.interestManager;
    }

    private static class ActiveCpuIterator implements Iterator<ICraftingCPU> {
        private final Iterator<ICraftingCPU> iterator;
        private ICraftingCPU cpuCluster;

        public ActiveCpuIterator(final Collection<ICraftingCPU> o) {
            this.iterator = o.iterator();
            this.cpuCluster = null;
        }

        @Override
        public boolean hasNext() {
            this.findNext();

            return this.cpuCluster != null;
        }

        private void findNext() {
            while (this.iterator.hasNext() && this.cpuCluster == null) {
                this.cpuCluster = this.iterator.next();
                if (!this.cpuCluster.isActive() || this.cpuCluster.isDestroyed()) {
                    this.cpuCluster = null;
                }
            }
        }

        @Override
        public ICraftingCPU next() {
            final ICraftingCPU o = this.cpuCluster;
            this.cpuCluster = null;

            return o;
        }

        @Override
        public void remove() {
            // no..
        }
    }
}