package com.ewt.i18n.core.localization;


import java.util.Objects;
import java.util.Optional;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import com.ewt.common.time.TimeSupplier;
import com.ewt.commons.result.Result;
import com.ewt.dictionary.api.DictionaryEntry;
import com.ewt.dictionary.cache.DictionaryCodeCache;
import com.ewt.domain.user.User;
import com.ewt.i18n.api.common.UpdateLocaleError;
import com.ewt.i18n.api.localization.create.CreateLocalizationError;
import com.ewt.i18n.api.localization.create.CreateLocalizationRequest;
import com.ewt.i18n.core.key.dao.KeyDAO;
import com.ewt.i18n.core.locale.dao.LocaleDAO;
import com.ewt.i18n.core.localization.dao.LocalizationDAO;
import com.ewt.i18n.core.localization.dao.LocalizationKey;
import com.ewt.i18n.core.localization.dao.LocalizationKeyDAO;
import com.ewt.i18n.event.api.EventTypes;
import com.ewt.i18n.event.api.LocalizationKeyValueUpdatedEvent;
import com.ewt.i18n.event.exporter.LocalizationKeyValueUpdatedEventExporter;


/**
 * Менеджер управления локализациями.
 *
 * @author Klyushkin A. <aklyushkin@marathonbet.ru>.
 */
@Component
public class LocalizationManager
{
    private static final Logger logger = LoggerFactory.getLogger(LocalizationManager.class);

    private static final Result<Void, CreateLocalizationError> LOCALE_NOT_FOUND =
        Result.failed(CreateLocalizationError.LOCALE_NOT_FOUND);

    private static final Result<Void, CreateLocalizationError> LOCALIZATION_ALREADY_EXIST =
        Result.failed(CreateLocalizationError.LOCALIZATION_ALREADY_EXIST);

    private final DictionaryCodeCache localeCache;

    private final LocaleDAO localeDAO;

    private final KeyDAO keyDAO;

    private final LocalizationKeyDAO localizationKeyDAO;

    private final LocalizationDAO localizationDAO;

    private final LocalizationKeyValueUpdatedEventExporter localizationKeyValueUpdatedEventExporter;

    private final TimeSupplier timeSupplier;


    @Autowired
    public LocalizationManager(final DictionaryCodeCache localeCache,
                               final LocaleDAO localeDAO,
                               final KeyDAO keyDAO,
                               final LocalizationKeyDAO localizationKeyDAO,
                               final LocalizationDAO localizationDAO,
                               final LocalizationKeyValueUpdatedEventExporter localizationKeyValueUpdatedEventExporter,
                               final TimeSupplier timeSupplier)
    {
        this.localeCache = localeCache;
        this.localeDAO = localeDAO;
        this.keyDAO = keyDAO;
        this.localizationKeyDAO = localizationKeyDAO;
        this.localizationDAO = localizationDAO;
        this.localizationKeyValueUpdatedEventExporter = localizationKeyValueUpdatedEventExporter;
        this.timeSupplier = timeSupplier;
    }


    /**
     * Обновление локализации.
     *
     * Перед обновлением локализации сначала выполняется инкремент локали,
     * и новая версия локали используется как новая версия локализации.
     *
     * @param localizationId идентифкатор локализации
     * @param text           новое значение лоаклизации
     * @param user           пользователь, иницировавший изменение
     * @param version        версия локали
     * @return результат обновления локализации
     */
    @Transactional
    public Result<Void, UpdateLocaleError> updateLocalization(final long localizationId,
                                                              final String text,
                                                              final User user,
                                                              final long version)
    {
        logger.debug("updateLocalization(): user={}, localizationId={}, text={}, version={}", user, localizationId, text, version);

        localizationKeyValueUpdatedEventExporter.export(
                LocalizationKeyValueUpdatedEvent.builder()
                        .withEventId(UUID.randomUUID())
                        .withEventDate(timeSupplier.getCurrentTime())
                        .withActor(user)
                        .withI18nKey()                                              //from where
                        .withLocale()                                               //from where
                        .withNewValue()                                             //from where
                        .withOldValue()                                             //from where
                        .withEventType(EventTypes.LOCALIZATION_KEY_UPDATED)
                        .build());

        return localizationKeyDAO.getLocalizationKey(localizationId)
                .map(LocalizationKey::getLocaleId)
                .map(localeId -> updateLocaleVersion(localeId, localizationId, version, text, user))
                .orElseGet(() -> {
                    logger.info("Localization not found: localizationId={}, version={}", localizationId, version);
                    return Result.failed(UpdateLocaleError.LOCALIZATION_NOT_FOUND);
                });

    }


    private Result<Void, UpdateLocaleError> updateLocaleVersion(final Long localeId,
                                                                final Long localizationId,
                                                                final Long version,
                                                                final String text,
                                                                final User user)
    {
        logger.debug("Update localization version: localizationId={}, version={}, text={}, user={}", localizationId, version, text, user);

        final Long newLocaleVersion = localeDAO.updateLocaleVersion(localeId);

        final boolean isUpdated = localizationDAO.updateLocalization(localizationId, text, version, newLocaleVersion);

        if (!isUpdated)
        {
            logger.info("Localization version conflict: localizationId={}, version={}, text={}, user={}", localizationId, version, text, user);

            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

            return Result.failed(UpdateLocaleError.VERSION_CONFLICT);
        }

        localizationDAO.updateLocalizationHistory(localizationId, text, newLocaleVersion, user);

        return Result.success();
    }


    /**
     * Добавление локализации.
     *
     * @param request {@link CreateLocalizationRequest}
     * @return Результат обновления локализации.
     */
    @Transactional
    public Result<Void, CreateLocalizationError> createLocalization(final CreateLocalizationRequest request)
    {
        logger.debug("createLocalization(): request={}", request);

        final Optional<Long> localeIdOptional = localeCache.get(request.getLocale().asString()).map(DictionaryEntry::getId);
        if (!localeIdOptional.isPresent())
        {
            logger.info("locale not found: locale = {}", request.getLocale());
            return LOCALE_NOT_FOUND;
        }

        final Long localeId = localeIdOptional.get();

        final Long keyId = keyDAO.addKey(request.getKey());

        final Long newLocaleVersion = localeDAO.updateLocaleVersion(localeIdOptional.get());

        final Long localizationKeyId = localizationKeyDAO.addLocalizationKey(keyId, localeId).orElse(null);
        if (Objects.isNull(localizationKeyId))
        {
            logger.info("localization already exist: key = {}, locale={}", request.getKey(), request.getLocale());
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return LOCALIZATION_ALREADY_EXIST;
        }

        localizationDAO.insertLocalization(localizationKeyId, request.getText(), newLocaleVersion);
        localizationDAO.updateLocalizationHistory(localizationKeyId, request.getText(), newLocaleVersion, request.getUser());

        localizationKeyValueUpdatedEventExporter.export(
                LocalizationKeyValueUpdatedEvent.builder()
                        .withEventId(UUID.randomUUID())
                        .withEventDate(timeSupplier.getCurrentTime())
                        .withActor(request.getUser())
                        .withI18nKey(request.getKey().toString())
                        .withLocale(request.getLocale())
                        .withNewValue()             //from where
                        .withOldValue()             //from where
                        .withEventType(EventTypes.LOCALIZATION_KEY_CREATED)
                        .build());

        return Result.success();
    }
}