Applied-Energistics-2-tilera-Edition/src/main/java/appeng/crafting/MECraftingInventory.java

/*
 * 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.crafting;

import appeng.api.AEApi;
import appeng.api.config.Actionable;
import appeng.api.networking.security.BaseActionSource;
import appeng.api.storage.IMEInventory;
import appeng.api.storage.IMEMonitor;
import appeng.api.storage.StorageChannel;
import appeng.api.storage.data.IAEItemStack;
import appeng.api.storage.data.IItemList;
import appeng.util.inv.ItemListIgnoreCrafting;

public class MECraftingInventory implements IMEInventory<IAEItemStack> {
    private final MECraftingInventory par;

    private final IMEInventory<IAEItemStack> target;
    private final IItemList<IAEItemStack> localCache;

    private final boolean logExtracted;
    private final IItemList<IAEItemStack> extractedCache;

    private final boolean logInjections;
    private final IItemList<IAEItemStack> injectedCache;

    private final boolean logMissing;
    private final IItemList<IAEItemStack> missingCache;

    public MECraftingInventory() {
        this.localCache
            = new ItemListIgnoreCrafting<>(AEApi.instance().storage().createItemList());
        this.extractedCache = null;
        this.injectedCache = null;
        this.missingCache = null;
        this.logExtracted = false;
        this.logInjections = false;
        this.logMissing = false;
        this.target = null;
        this.par = null;
    }

    public MECraftingInventory(final MECraftingInventory parent) {
        this.target = parent;
        this.logExtracted = parent.logExtracted;
        this.logInjections = parent.logInjections;
        this.logMissing = parent.logMissing;

        if (this.logMissing) {
            this.missingCache = AEApi.instance().storage().createItemList();
        } else {
            this.missingCache = null;
        }

        if (this.logExtracted) {
            this.extractedCache = AEApi.instance().storage().createItemList();
        } else {
            this.extractedCache = null;
        }

        if (this.logInjections) {
            this.injectedCache = AEApi.instance().storage().createItemList();
        } else {
            this.injectedCache = null;
        }

        this.localCache = this.target.getAvailableItems(
            new ItemListIgnoreCrafting<>(AEApi.instance().storage().createItemList())
        );

        this.par = parent;
    }

    public MECraftingInventory(
        final IMEMonitor<IAEItemStack> target,
        final BaseActionSource src,
        final boolean logExtracted,
        final boolean logInjections,
        final boolean logMissing
    ) {
        this.target = target;
        this.logExtracted = logExtracted;
        this.logInjections = logInjections;
        this.logMissing = logMissing;

        if (logMissing) {
            this.missingCache = AEApi.instance().storage().createItemList();
        } else {
            this.missingCache = null;
        }

        if (logExtracted) {
            this.extractedCache = AEApi.instance().storage().createItemList();
        } else {
            this.extractedCache = null;
        }

        if (logInjections) {
            this.injectedCache = AEApi.instance().storage().createItemList();
        } else {
            this.injectedCache = null;
        }

        this.localCache
            = new ItemListIgnoreCrafting<>(AEApi.instance().storage().createItemList());
        for (final IAEItemStack is : target.getStorageList()) {
            this.localCache.add(target.extractItems(is, Actionable.SIMULATE, src));
        }

        this.par = null;
    }

    public MECraftingInventory(
        final IMEInventory<IAEItemStack> target,
        final boolean logExtracted,
        final boolean logInjections,
        final boolean logMissing
    ) {
        this.target = target;
        this.logExtracted = logExtracted;
        this.logInjections = logInjections;
        this.logMissing = logMissing;

        if (logMissing) {
            this.missingCache = AEApi.instance().storage().createItemList();
        } else {
            this.missingCache = null;
        }

        if (logExtracted) {
            this.extractedCache = AEApi.instance().storage().createItemList();
        } else {
            this.extractedCache = null;
        }

        if (logInjections) {
            this.injectedCache = AEApi.instance().storage().createItemList();
        } else {
            this.injectedCache = null;
        }

        this.localCache
            = target.getAvailableItems(AEApi.instance().storage().createItemList());
        this.par = null;
    }

    @Override
    public IAEItemStack injectItems(
        final IAEItemStack input, final Actionable mode, final BaseActionSource src
    ) {
        if (input == null) {
            return null;
        }

        if (mode == Actionable.MODULATE) {
            if (this.logInjections) {
                this.injectedCache.add(input);
            }
            this.localCache.add(input);
        }

        return null;
    }

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

        final IAEItemStack list = this.localCache.findPrecise(request);
        if (list == null || list.getStackSize() == 0) {
            return null;
        }

        if (list.getStackSize() >= request.getStackSize()) {
            if (mode == Actionable.MODULATE) {
                list.decStackSize(request.getStackSize());
                if (this.logExtracted) {
                    this.extractedCache.add(request);
                }
            }

            return request;
        }

        final IAEItemStack ret = request.copy();
        ret.setStackSize(list.getStackSize());

        if (mode == Actionable.MODULATE) {
            list.reset();
            if (this.logExtracted) {
                this.extractedCache.add(ret);
            }
        }

        return ret;
    }

    @Override
    public IItemList<IAEItemStack> getAvailableItems(final IItemList<IAEItemStack> out) {
        for (final IAEItemStack is : this.localCache) {
            out.add(is);
        }

        return out;
    }

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

    public IItemList<IAEItemStack> getItemList() {
        return this.localCache;
    }

    public boolean commit(final BaseActionSource src) {
        final IItemList<IAEItemStack> added = AEApi.instance().storage().createItemList();
        final IItemList<IAEItemStack> pulled
            = AEApi.instance().storage().createItemList();
        boolean failed = false;

        if (this.logInjections) {
            for (final IAEItemStack inject : this.injectedCache) {
                IAEItemStack result = null;
                added.add(
                    result = this.target.injectItems(inject, Actionable.MODULATE, src)
                );

                if (result != null) {
                    failed = true;
                    break;
                }
            }
        }

        if (failed) {
            for (final IAEItemStack is : added) {
                this.target.extractItems(is, Actionable.MODULATE, src);
            }

            return false;
        }

        if (this.logExtracted) {
            for (final IAEItemStack extra : this.extractedCache) {
                IAEItemStack result = null;
                pulled.add(
                    result = this.target.extractItems(extra, Actionable.MODULATE, src)
                );

                if (result == null || result.getStackSize() != extra.getStackSize()) {
                    failed = true;
                    break;
                }
            }
        }

        if (failed) {
            for (final IAEItemStack is : added) {
                this.target.extractItems(is, Actionable.MODULATE, src);
            }

            for (final IAEItemStack is : pulled) {
                this.target.injectItems(is, Actionable.MODULATE, src);
            }

            return false;
        }

        if (this.logMissing && this.par != null) {
            for (final IAEItemStack extra : this.missingCache) {
                this.par.addMissing(extra);
            }
        }

        return true;
    }

    private void addMissing(final IAEItemStack extra) {
        this.missingCache.add(extra);
    }

    void ignore(final IAEItemStack what) {
        final IAEItemStack list = this.localCache.findPrecise(what);
        if (list != null) {
            list.setStackSize(0);
        }
    }
}