no-copy/src/main/java/ru/soune/nocopy/service/tariff/TariffInitializationService.java

package ru.soune.nocopy.service.tariff;

import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.soune.nocopy.entity.tarif.Tariff;
import ru.soune.nocopy.entity.tarif.TariffType;
import ru.soune.nocopy.repository.TariffRepository;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
@RequiredArgsConstructor
public class TariffInitializationService {

    @Value("${tarif.demo-price}")
    private long demoPrice;

    @Value("${tarif.demo-tokens}")
    private int demoTokens;

    @Value("${tarif.demo-user-count}")
    private long demoUserCount;

    @Value("${tarif.demo-max-files-count}")
    private int demoMaxFileCount;

    @Value("${tarif.start-price}")
    private long startPrice;

    @Value("${tarif.start-tokens}")
    private int startTokens;

    @Value("${tarif.start-max-files-count}")
    private int startMaxFileCount;

    @Value("${tarif.start-user-count}")
    private long startUserCount;

    @Value("${tarif.basic-price}")
    private long basicPrice;

    @Value("${tarif.basic-tokens}")
    private int basicTokens;

    @Value("${tarif.basic-max-files-count}")
    private int basicMaxFileCount;

    @Value("${tarif.basic-user-count}")
    private long basicUserCount;

    @Value("${tarif.pro-price}")
    private long proPrice;

    @Value("${tarif.pro-tokens}")
    private int proTokens;

    @Value("${tarif.pro-max-files-count}")
    private int proMaxFileCount;

    @Value("${tarif.pro-user-count}")
    private long proUserCount;

    @Value("${tarif.enterprice-price}")
    private long enterpricePrice;

    @Value("${tarif.enterprice-tokens}")
    private int enterpriceTokens;

    @Value("${tarif.enterprice-max-files-count}")
    private int enterpriceMaxFileCount;

    @Value("${tarif.enterprice-user-count}")
    private long enterpriceUserCount;

    private final TariffRepository tariffRepository;

    @EventListener(ApplicationReadyEvent.class)
    @Transactional
    public void initializeDefaultTariffs() {
        List<Tariff> existingTariffs = tariffRepository.findAll();

        if (existingTariffs.isEmpty()) {
            createDefaultTariffs();
        }
    }

    private void createDefaultTariffs() {
        Arrays.stream(TariffType.values())
                .forEach(this::createDefaultTariff);
    }

    private void createDefaultTariff(TariffType type) {
        Tariff tariff = new Tariff();
        tariff.setType(type.name());

        switch (type) {
            case DEMO:
                tariff.setName("Демо");
                tariff.setPrice(demoPrice);
                tariff.setTokens(demoTokens);
                tariff.setMaxFilesCount(demoMaxFileCount);
                tariff.setDiskSize(1024L * 1024 * 100);
                tariff.setMaxUsers(demoUserCount);
                break;

            case START:
                tariff.setName("Стартовый");
                tariff.setPrice(startPrice);
                tariff.setTokens(startTokens);
                tariff.setMaxFilesCount(startMaxFileCount);
                tariff.setDiskSize(1024L * 1024 * 500);
                tariff.setMaxUsers(startUserCount);
                break;

            case BASIC:
                tariff.setName("Базовый");
                tariff.setPrice(basicPrice);
                tariff.setTokens(basicTokens);
                tariff.setMaxFilesCount(basicMaxFileCount);
                tariff.setDiskSize(1024L * 1024 * 1024 * 2L);
                tariff.setMaxUsers(basicUserCount);
                break;

            case PRO:
                tariff.setName("Профессиональный");
                tariff.setPrice(proPrice);
                tariff.setTokens(proTokens);
                tariff.setMaxFilesCount(proMaxFileCount);
                tariff.setDiskSize(1024L * 1024 * 1024 * 10L);
                tariff.setMaxUsers(proUserCount);
                break;

            case ENTERPRISE:
                tariff.setName("Корпоративный");
                tariff.setPrice(enterpricePrice);
                tariff.setTokens(enterpriceTokens);
                tariff.setMaxFilesCount(enterpriceMaxFileCount);
                tariff.setDiskSize(1024L * 1024 * 1024 * 50L);
                tariff.setMaxUsers(enterpriceUserCount);
                break;
        }

        tariffRepository.save(tariff);
    }
}