package ru.kayashov.bar.schedule;

import javax.transaction.Transactional;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import ru.kayashov.bar.model.api.translate.Translate;
import ru.kayashov.bar.model.entity.CocktailEntity;
import ru.kayashov.bar.model.entity.IngredientEntity;
import ru.kayashov.bar.model.entity.ReceiptEntity;
import ru.kayashov.bar.model.entity.TypeEntity;
import ru.kayashov.bar.model.entity.Unit;
import ru.kayashov.bar.model.entity.UnitRepository;
import ru.kayashov.bar.repository.CocktailRepository;
import ru.kayashov.bar.repository.IngredientRepository;
import ru.kayashov.bar.repository.ReceiptRepository;
import ru.kayashov.bar.repository.TypeRepository;
import ru.kayashov.bar.service.integration.translate.TranslateService;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import static ru.kayashov.bar.service.integration.translate.TranslateService.translate;

@Slf4j
@Component
@RequiredArgsConstructor
public class Repairer {

    private final IngredientRepository ingredientRepository;
    private final TypeRepository tagRepository;
    private final CocktailRepository cocktailRepository;
    private final ReceiptRepository receiptRepository;
    private final UnitRepository unitRepository;

    //    @Transactional
//    @EventListener(ContextRefreshedEvent.class)
    public void repair() {
        unitRepository.findAll().stream()
                .peek(u -> u.setName(TranslateService.softTranslate(u.getName())))
                .forEach(unitRepository::save);

        log.info("repaired");
    }

    private Float convertValue(String value) {
        if (value.contains("-") || value.contains("/")) {
            float f;
            if (value.contains("-")) {
                f = average(value);
            } else if (value.contains("/")) {
                f = drob(value);
            } else {
                f = Float.parseFloat(value);
            }
            return f;
        }
        try {
            return Float.parseFloat(value);
        } catch (NumberFormatException e) {
            return null;
        }
    }

    //    @Transactional
//    @EventListener(ContextRefreshedEvent.class)
    public void repairAllowed() {
        List<CocktailEntity> cocktailEntities = cocktailRepository.findAll();

        for (CocktailEntity cocktail : cocktailEntities) {
            List<ReceiptEntity> receipts = cocktail.getReceipt();
//            if(receipts.stream().allMatch(r -> r.getIngredient().getIsHave())) {
//                cocktail.setIsAllowed(true);
//            } else {
//                cocktail.setIsAllowed(false);
//            }
            cocktailRepository.save(cocktail);
        }
        log.info("Cocktails have been repaired");
    }

    @Transactional
//    @EventListener(ContextRefreshedEvent.class)
    public void repairReceipts() {
//        List<ReceiptEntity> receipts = receiptRepository.findAll()
//                .stream()
//                .filter(r -> r.getMeasureText() != null && r.getMeasure() == null)
//                .filter(r -> r.getMeasureText().contains("Slice"))
//                .filter(r -> r.getMeasureText().split(" ").length == 2)
//                .toList();
//        for (ReceiptEntity receipt : receipts) {
//            String[] split = receipt.getMeasureText().split(" ");
//            if (split[1].equalsIgnoreCase("Slice")) {
//                receipt.setUnitText(split[1]);
//            } else {
//                continue;
//            }
//            log.info("convert {} - {}", receipt.getId(), receipt.getMeasureText());
//
//            String measure = split[0];
//            Float f;
//            if (measure.contains("-")) {
//                f = average(measure);
//            } else if (measure.contains("/")) {
//                f = drob(measure);
//            } else {
//                f = Float.parseFloat(measure);
//            }
//
//            receipt.setMeasure(f == 0 ? null : f);
//            receiptRepository.save(receipt);
//        }
        log.info("repaired");
    }

    private Float average(String s) {
        String[] split = s.split("-");
        float sum = 0f;
        for (String str : split) {
            if (str.contains("/")) {
                sum += drob(str);
            } else {
                sum += Float.parseFloat(str);
            }
        }
        return sum / split.length;
    }

    private Float drob(String s) {
        String[] split = s.split("/");
        return Float.parseFloat(split[0]) / Float.parseFloat(split[1]);
    }

    //    @Transactional
//    @EventListener(ContextRefreshedEvent.class)
    public void repairEnTag() {
        List<TypeEntity> tagEntities = tagRepository.findAll()
                .stream()
                .filter(t -> t.getName() == null)
                .toList();
        for (TypeEntity tagEntity : tagEntities) {
            tagEntity.setName(translate(tagEntity.getEnName()));
            tagRepository.save(tagEntity);
            log.info("tag {} saved", tagEntity.getName());
        }
        log.info("repaired");
    }


    public void repairEnIngredients() {
        List<IngredientEntity> ingredients = ingredientRepository.findAll().stream()
                .filter(i -> i.getName() == null)
//                .filter(i -> i.getDescription() == null && i.getEnDescription() != null && !i.getEnDescription().isEmpty())
                .toList();

        for (IngredientEntity i : ingredients) {
            boolean needSave = false;
            if (i.getName() == null) {
                String s = translate(i.getEnName());
                i.setName(s);
                needSave = true;
            }
            if (i.getDescription() == null) {
//                String s = translate(i.getEnDescription());
//                i.setDescription(s);
                needSave = true;
            }
            if (needSave) {
                ingredientRepository.save(i);
                log.info("Ingredient {} saved", i.getName());
            }
        }
    }
}