package ru.nbch.indicsearchservice.loader;

import java.io.IOException;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.apache.ibatis.cursor.Cursor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import ru.nbch.indicsearchservice.exception.InternalException;
import ru.nbch.indicsearchservice.loader.subtable.RuUidSubTableLoader;
import ru.nbch.indicsearchservice.model.TableMetaData;
import ru.nbch.indicsearchservice.model.enums.DataType;
import ru.nbch.indicsearchservice.model.enums.SearchParameter;
import ru.nbch.indicsearchservice.util.IndicSearchCommon;
import ru.nbch.indicsearchservice.util.IndicSearchUtils;
import ru.nbch.indicsearchservice.util.MapperHolder;

@Component
public class RuUidTableLoader implements FirstLevelTableLoader, TableLoaderForId {
    private final MapperHolder mapperHolder;
    private final IndicSearchUtils indicSearchUtils;
    private final List<RuUidSubTableLoader> ruUidSubTableLoaders;

    public RuUidTableLoader(MapperHolder mapperHolder,
                            IndicSearchUtils indicSearchUtils,
                            List<RuUidSubTableLoader> ruUidSubTableLoaders) {
        this.mapperHolder = mapperHolder;
        this.indicSearchUtils = indicSearchUtils;
        this.ruUidSubTableLoaders = ruUidSubTableLoaders;
    }

    @Override
    public String getTableName() {
        return "RU_UID";
    }

    @Override
    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
            (searchParameter == SearchParameter.UUID ||
                searchParameter == SearchParameter.ACCT_NUM ||
                searchParameter == SearchParameter.FID ||
                searchParameter == SearchParameter.PASSPORT ||
                searchParameter == SearchParameter.OGRN)) {
            Set<String> result = new HashSet<>();

            result.add(getTableName());
            result.addAll(ruUidSubTableLoaders.stream().map(TableLoader::getTableName).toList());

            return result;
        }

        return Set.of();
    }

    @Override
    @Transactional(readOnly = true)
    public void searchBy(UUID taskId,
                         DataType dataType,
                         SearchParameter searchParameter,
                         String searchValue,
                         String memberCode,
                         Map<String, Path> tableFileMap,
                         Map<String, TableMetaData> tableMetaDataMap) {
        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
            if (searchParameter == SearchParameter.UUID) {
                if (IndicSearchCommon.isCastableField(getTableName(), "UUID")) {
                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("UUID").getColumnSize();
                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
                }
                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByUuidAndMemberCodeFromRuUid(searchValue, memberCode)) {
                    Set<Integer> foundFids = new HashSet<>();
                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids, tableMetaDataMap));
                    ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, foundFids, tableFileMap, tableMetaDataMap));
                } catch (IOException e) {
                    throw new InternalException("Failed to read cursor " + e);
                }
            } else if (searchParameter == SearchParameter.ACCT_NUM) {
                if (IndicSearchCommon.isCastableField(getTableName(), "ACCT_NUM")) {
                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("ACCT_NUM").getColumnSize();
                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
                }
                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByAcctNumAndMemberCodeFromRuUid(searchValue, memberCode)) {
                    Set<Integer> foundFids = new HashSet<>();
                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids, tableMetaDataMap));
                    ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, foundFids, tableFileMap, tableMetaDataMap));
                } catch (IOException e) {
                    throw new InternalException("Failed to read cursor " + e);
                }
            } else if (searchParameter == SearchParameter.FID) {
                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));

                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuUid(fids)) {
                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
                    ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, fids, tableFileMap, tableMetaDataMap));
                } catch (IOException e) {
                    throw new InternalException("Failed to read cursor " + e);
                }
            }
        }
    }

    @Override
    @Transactional(readOnly = true)
    public void searchById(UUID taskId,
                           DataType dataType,
                           SearchParameter searchParameter,
                           Set<Integer> fids,
                           String memberCode,
                           Map<String, Path> tableFileMap,
                           Map<String, TableMetaData> tableMetaDataMap) {
        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
                if (!fids.isEmpty()) {
                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuUid(fids)) {
                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
                        ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, fids, tableFileMap, tableMetaDataMap));
                    } catch (IOException e) {
                        throw new InternalException("Failed to read cursor " + e);
                    }
                }
            }
        }
    }
}