Arakne / Araknemu

 * This file is part of Araknemu.

 *

 * Araknemu 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.

 *

 * Araknemu 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 Araknemu.  If not, see <https://www.gnu.org/licenses/>.

 *

 * Copyright (c) 2017-2020 Vincent Quatrevieux

 */

package fr.quatrevieux.araknemu.game.item;

import fr.quatrevieux.araknemu.data.value.ItemTemplateEffectEntry;

import fr.quatrevieux.araknemu.data.world.entity.item.ItemSet;

import fr.quatrevieux.araknemu.data.world.entity.item.ItemTemplate;

import fr.quatrevieux.araknemu.data.world.repository.item.ItemSetRepository;

import fr.quatrevieux.araknemu.data.world.repository.item.ItemTemplateRepository;

import fr.quatrevieux.araknemu.data.world.repository.item.ItemTypeRepository;

import fr.quatrevieux.araknemu.game.PreloadableService;

import fr.quatrevieux.araknemu.game.item.effect.CharacteristicEffect;

import fr.quatrevieux.araknemu.game.item.effect.SpecialEffect;

import fr.quatrevieux.araknemu.game.item.effect.mapping.EffectMapper;

import fr.quatrevieux.araknemu.game.item.factory.ItemFactory;

import org.apache.logging.log4j.Logger;

import org.checkerframework.checker.index.qual.Positive;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

/**

 * Service for handle items

 */

public final class ItemService implements PreloadableService {

    private final ItemTemplateRepository repository;

    private final ItemFactory factory;

    private final ItemSetRepository itemSetRepository;

    private final ItemTypeRepository itemTypeRepository;

    private final EffectMapper<CharacteristicEffect> characteristicEffectEffectMapper;

    private final EffectMapper<SpecialEffect> specialEffectEffectMapper;

    private final ConcurrentMap<Integer, GameItemSet> itemSetsById = new ConcurrentHashMap<>();

    public ItemService(ItemTemplateRepository repository, ItemFactory factory, ItemSetRepository itemSetRepository, ItemTypeRepository itemTypeRepository, EffectMapper<CharacteristicEffect> characteristicEffectEffectMapper, EffectMapper<SpecialEffect> specialEffectEffectMapper) {

        this.repository = repository;

        this.factory = factory;

        this.itemSetRepository = itemSetRepository;

        this.itemTypeRepository = itemTypeRepository;

        this.characteristicEffectEffectMapper = characteristicEffectEffectMapper;

        this.specialEffectEffectMapper = specialEffectEffectMapper;

    }

    @Override

    public void preload(Logger logger) {

        loadItemTypes(logger);

        loadItemSets(logger);

        loadItems(logger);

    }

    @Override

    public String name() {

        return "item";

    }

    /**

     * Create a new item

     *

     * @param id The item template id

     * @param maximize Maximize item stats ?

     */

    public Item create(int id, boolean maximize) {

        return create(repository.get(id), maximize);

    }

    /**

     * Create a new item

     *

     * @param id The item template id

     */

    public Item create(int id) {

        return create(id, false);

    }

    /**

     * Create a new item by its template

     *

     * @param template The item template

     * @param maximize Maximize item stats ?

     */

    public Item create(ItemTemplate template, boolean maximize) {

        return factory.create(

            template,

            itemTypeRepository.get(template.type()),

            template.itemSet() == 0

                ? null

                : itemSet(template.itemSet()),

            maximize

        );

    }

    /**

     * Create a new item by its template

     *

     * @param template The item template

     */

    public Item create(ItemTemplate template) {

        return create(template, false);

    }

    /**

     * Creates many times an item, with random stats on each creation

     *

     * @param template The item template to generates

     * @param quantity The desired quantity

     *

     * @return Map of item associated with the quantity

     */

    public Map<Item, @Positive Integer> createBulk(ItemTemplate template, @Positive int quantity) {

        final Map<Item, @Positive Integer> items = new HashMap<>();

        for (int count = 0; count < quantity; ++count) {

            final Item generated = create(template);

            items.merge(generated, 1, (a, b) -> a + b); // Do not use Integer::sum because it does not handle @Positive

        }

        return items;

    }

    /**

     * Retrieve an item with its effects

     *

     * @param id The item template id

     * @param effects The item effects

     */

    }

    /**

     * Get an item set

     *

     * @param id The item set id

     *

     * @throws fr.quatrevieux.araknemu.core.dbal.repository.EntityNotFoundException When the item set do not exists

     */

    public GameItemSet itemSet(int id) {

        return itemSetsById.computeIfAbsent(id, mid -> createItemSet(itemSetRepository.get(id)));

    }

    private GameItemSet createItemSet(ItemSet entity) {

        final List<GameItemSet.Bonus> bonuses = new ArrayList<>();

        for (List<ItemTemplateEffectEntry> effects : entity.bonus()) {

            bonuses.add(

                new GameItemSet.Bonus(

                    effects,

                    characteristicEffectEffectMapper.create(effects),

                    specialEffectEffectMapper.create(effects)

                )

            );

        }

        return new GameItemSet(entity, bonuses);

    }

    private void loadItems(Logger logger) {

        logger.info("Loading items...");

        final int loaded = repository.load().size();

        logger.info("Successfully load {} items", loaded);

    }

    private void loadItemSets(Logger logger) {

        logger.info("Loading item sets...");

        for (ItemSet entity : itemSetRepository.load()) {

            itemSetsById.put(entity.id(), createItemSet(entity));

        }

        logger.info("Successfully load {} item sets", itemSetsById.size());

    }

    private void loadItemTypes(Logger logger) {

        logger.info("Loading item types...");

        logger.info("Successfully load {} item sets", itemTypeRepository.load().size());

    }

}