package app.services;

import app.entities.PlayerProfile;
import app.entities.db.Ban;
import app.entities.Killfeed;
import app.entities.other.SteamID;
import app.entities.report.ReportCount;
import app.exceptions.BaseWebException;
import app.services.db.*;
import app.services.steam.SteamWebApi;
import app.utils.SteamIDConverter;
import app.utils.SteamInviteConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.Instant;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Supplier;

@Service
public class ProfileService {
    SteamWebApi steamWebApi;
    public UsertimeService usertimeService;
    PermitionService permitionService;
    StatsService statsService;
    BanService banService;
    DiscordAuthService discordAuthService;
    DetectService detectService;
    DonateService donateService;
    MessageService messageService;
    KillfeedService killfeedService;
    ReportService reportService;

    @Autowired
    public ProfileService(SteamWebApi steamWebApi,
                          UsertimeService usertimeService,
                          PermitionService permitionService,
                          StatsService statsService,
                          BanService banService,
                          DiscordAuthService discordAuthService,
                          DetectService detectService,
                          DonateService donateService,
                          MessageService messageService,
                          KillfeedService killfeedService,
                          ReportService reportService) {
        this.steamWebApi = steamWebApi;
        this.usertimeService = usertimeService;
        this.permitionService = permitionService;
        this.statsService = statsService;
        this.banService = banService;
        this.discordAuthService = discordAuthService;
        this.detectService = detectService;
        this.donateService = donateService;
        this.messageService = messageService;
        this.killfeedService = killfeedService;
        this.reportService = reportService;
    }

    public PlayerProfile GetProfile(SteamID steamID, List<String> requests) {
        return GetProfile(steamID.steam64, requests);
    }

    public PlayerProfile GetProfile(Long steam64, List<String> requests){
        return GetProfile(steam64.toString(), requests);
    }

    public PlayerProfile GetProfile(String steam64, List<String> requests) {
        if (steam64 == null) return null;
        SteamID steamID = SteamIDConverter.getSteamID(steam64);
        if (null == steamID) return null;

        final int requests_pool = 4;
        ExecutorService executor = Executors.newFixedThreadPool(requests_pool);
        Set<Callable<Supplier>> callables = new HashSet<>(requests_pool);

        PlayerProfile profile = new PlayerProfile();
        profile.setResponse_time(new HashMap<>());

        profile.setSteamids(steamID);


        callables.add(() -> {
            try {
                long start_time = Instant.now().toEpochMilli();
                profile.setPlay_on(statsService.searchPlayer(steamID));
                long end_time = Instant.now().toEpochMilli() - start_time;
                profile.getResponse_time().put("play_on", (double) end_time / 1000);
            } catch (Exception err) {
                err.printStackTrace();
            }
            return null;
        });


        if(requests.contains("steam_data")){
            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    profile.setSteam_data(steamWebApi.getSteamData(steamID.steam64));
                    long end_time = Instant.now().toEpochMilli() - start_time;
                    profile.getResponse_time().put("steam_data", (double) end_time / 1000);
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });
        }

        if(requests.contains("lastplay")){
            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    profile.setLastplay(usertimeService.getPlayerLastplay(steamID));
                    long end_time = Instant.now().toEpochMilli() - start_time;
                    profile.getResponse_time().put("lastplay", (double) end_time / 1000);
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });
        }

        if(requests.contains("usertime")){
            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    profile.setGametime(usertimeService.getPlayerUsertime(steamID));
                    long end_time = Instant.now().toEpochMilli() - start_time;
                    profile.getResponse_time().put("usertime", (double) end_time / 1000);
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });
        }

        //if(requests.contains("permition")){
        callables.add(() -> {
            try {
                long start_time = Instant.now().toEpochMilli();
                profile.setPermition(permitionService.getPermition(steamID));
                long end_time = Instant.now().toEpochMilli() - start_time;
                profile.getResponse_time().put("permition", (double) end_time / 1000);
            } catch (Exception err) {
                err.printStackTrace();
            }
            return null;
            });
        //}

        //if(requests.contains("ban")){
        callables.add(() -> {
            try {
                long start_time = Instant.now().toEpochMilli();
                profile.setBan(banService.getBan(steamID));
                long end_time = Instant.now().toEpochMilli() - start_time;
                profile.getResponse_time().put("ban", (double) end_time / 1000);
            } catch (Exception err) {
                err.printStackTrace();
            }
            return null;
        });
        //}

        if(requests.contains("attached_discord")){
            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    profile.setAttached_discords(detectService.getAttachedDiscordAccountPerSteam(steamID));
                    long end_time = Instant.now().toEpochMilli() - start_time;
                    profile.getResponse_time().put("attached_discord", (double) end_time / 1000);
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });
        }

        if(requests.contains("donates")){
            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    profile.setDonates(donateService.getDonateStatistic(steamID));
                    long end_time = Instant.now().toEpochMilli() - start_time;
                    profile.getResponse_time().put("donates", (double) end_time / 1000);
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });
        }

        if(requests.contains("ban_list")){
            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    profile.setBan_list(banService.getBans(steamID));
                    long end_time = Instant.now().toEpochMilli() - start_time;
                    profile.getResponse_time().put("ban_list", (double) end_time / 1000);
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });
        }

        if(requests.contains("killfeed")) {
            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    profile.setKillfeed((new Killfeed())
                            .setKills(killfeedService.getKills(steamID, null, null))
                            .setDeads(killfeedService.getDeads(steamID, null, null))
                            .setAssists(killfeedService.getAssists(steamID, null, null))
                            .setSuicides(killfeedService.getSuicides(steamID, null, null)));
                    long end_time = Instant.now().toEpochMilli() - start_time;
                    profile.getResponse_time().put("killfeed", (double) end_time / 1000);
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });

            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    Long currentPlayerTimeSession = statsService.searchCurrentPlayerStartTime(steamID);
                    if (currentPlayerTimeSession != null) {
                        Long ses_start = Instant.now().getEpochSecond() - currentPlayerTimeSession;
                        profile.setKillfeed_current((new Killfeed())
                                .setKills(killfeedService.getKills(steamID, null, ses_start))
                                .setDeads(killfeedService.getDeads(steamID, null, ses_start))
                                .setAssists(killfeedService.getAssists(steamID, null, ses_start))
                                .setSuicides(killfeedService.getSuicides(steamID, null, ses_start)));
                    }
                    long end_time = Instant.now().toEpochMilli() - start_time;
                    profile.getResponse_time().put("killfeed_current", (double) end_time / 1000);
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });
        }

        if(requests.contains("reports")){
            callables.add(() -> {
                try {
                    long start_time = Instant.now().toEpochMilli();
                    profile.setReports(new ReportCount(
                            reportService.getCreatedReportsCount(steamID),
                            reportService.getReportsCount(steamID),
                            reportService.getCreatedSelfReportsCount(steamID)
                    ));
                    long end_time = Instant.now().toEpochMilli() - start_time;
                } catch (Exception err) {
                    err.printStackTrace();
                }
                return null;
            });
        }

        //if(requests.contains("messages")){
        callables.add(() -> {
            try {
                long start_time = Instant.now().toEpochMilli();
                profile.setMessages(messageService.getMessageCount(steamID, null));
                long end_time = Instant.now().toEpochMilli() - start_time;
                profile.getResponse_time().put("messages", (double) end_time / 1000);
            } catch (Exception err) {
                err.printStackTrace();
            }
                return null;
            });
        //}
        long start_time_total = 0;
        try {
            start_time_total = Instant.now().toEpochMilli();
            executor.invokeAll(callables);
        } catch (InterruptedException ie) {}
        finally {
            profile.getResponse_time().put("total", (double) (Instant.now().toEpochMilli() - start_time_total) / 1000);
            executor.shutdown();
        }

        return profile;
    }

    public PlayerProfile GetProfile(String steam64) {
        return GetProfile(steam64, List.of("steam_data,lastplay,usertime,permition,ban,attached_discord,donates,ban_list,killfeed,reports".split(",")));
    }

    public PlayerProfile GetProfile(String steam64, String requests) {
        if (requests == null || requests.isEmpty()) return GetProfile(steam64);
        return GetProfile(steam64, List.of(requests.split(",")));
    }

    public PlayerProfile GetProfileOnPlayerOnServers(String name, List<String> requests) {
        SteamID steamID = statsService.searchPlayer(name);
        if (steamID == null) return null;
        return GetProfile(steamID, requests);
    }

    public SteamID GetSteamIDFromAnyData(String any) {
        SteamID result;
        //Проверить что это дискорд ид
        if (any.startsWith("<@") && any.endsWith(">")) {
            String discord_id = any.split("<@", 2)[1].split(">", 2)[0];
            result = discordAuthService.getSteamIDofDiscordID(discord_id);
            if (result != null) return result;
        }
        //Проверить не играет ли чел с таким именем на сервере
        result = statsService.searchPlayer(any);
        if (result != null) return result;
        //Проверить возможно что это ид бана
        if (any.startsWith("#")) {
            String[] splitted = any.split("#", 2);
            int ban_id = Integer.parseInt(splitted[1]);
            Ban ban = banService.getBan(ban_id);
            if(ban != null) result = SteamIDConverter.getSteamID(ban.getSteam_id());
            if (result != null) return result;
        }
        //Проверить что это инвайт в друзья
        result = SteamInviteConverter.getSteamID(any);
        if (result != null) return result;
        //Проверить что возможно это ссылка на стим профиль с именем
        result = steamWebApi.getSteamID(any);
        if (result != null) return result;
        //Проверить что возможно это стим ид в любой интрапретации
        result = SteamIDConverter.getSteamID(any);
        if (result != null) return result;
        //Проверить что вводное это имя и проверить в БД
        result = usertimeService.getSteamOnUsername(any);
        return result;
    }

    public PlayerProfile prepareProfileToAction(String steam64, String kicked_steam64, String player_name) throws EmptyRequestPlayer, LowAdminPermition, NotFoundPlayer {
        if(kicked_steam64.isEmpty() && player_name.isEmpty()) throw new EmptyRequestPlayer();

        PlayerProfile profile = null;
        if(!kicked_steam64.isEmpty()) {
            profile = GetProfile(kicked_steam64, List.of());
        } else if (!player_name.isEmpty()) {
            profile = GetProfileOnPlayerOnServers(player_name, List.of());
        }

        if (profile == null) throw new NotFoundPlayer();
        if (!permitionService.CheckMorePowerfull(SteamIDConverter.getSteamID(steam64), profile.getSteamids())) throw new LowAdminPermition();
        return profile;
    }

    public class EmptyRequestPlayer extends BaseWebException {}
    public class LowAdminPermition extends BaseWebException {}
    public class NotFoundPlayer extends BaseWebException {}
}