package cc.mrbird.febs.dapp.soccer.service.Impl;

import cc.mrbird.febs.common.entity.FebsResponse;
import cc.mrbird.febs.dapp.soccer.dto.LeaguesApiDto;
import cc.mrbird.febs.dapp.soccer.dto.TeamsApiDto;
import cc.mrbird.febs.dapp.soccer.entity.*;
import cc.mrbird.febs.dapp.soccer.mapper.*;
import cc.mrbird.febs.dapp.soccer.service.CountryService;
import cc.mrbird.febs.dapp.soccer.util.SoccerResponseUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.List;

@Slf4j
@Service
@RequiredArgsConstructor
public class CountryServiceImpl extends ServiceImpl<SoccerCountriesMapper, SoccerCountries> implements CountryService {

    private final SoccerCountriesMapper soccerCountriesMapper;
    private final SoccerLeaguesMapper soccerLeaguesMapper;
    private final SoccerTimezoneMapper soccerTimezoneMapper;
    private final SoccerLeaguesSeasonsMapper soccerLeaguesSeasonsMapper;
    private final SoccerTeamMapper soccerTeamMapper;
    private final SoccerVenueMapper soccerVenueMapper;

    @Override
    public FebsResponse countries() {
        HttpResponse<String> httpResponse = null;
        try {
            httpResponse = Unirest.get("http://v3.football.api-sports.io/countries")
                    .header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
                    .header("x-rapidapi-host", "v3.football.api-sports.io").asString();
        } catch (UnirestException e) {
            e.printStackTrace();
        }

        JsonResponse jsonResponse = SoccerResponseUtil.getJsonResponse(httpResponse);
        if(ObjectUtil.isNotEmpty(jsonResponse)){
            List<Object> responses = jsonResponse.getResponse();
            if(CollUtil.isNotEmpty(responses)){
                for(Object list : responses){
                    JSONObject jsonObject = JSONUtil.parseObj(list);
                    String code = SoccerResponseUtil.objectToStr(jsonObject.get("code"));
                    List<SoccerCountries> soccerCountryList = soccerCountriesMapper.selectList(new QueryWrapper<SoccerCountries>().eq("code", code));
                    if(CollUtil.isNotEmpty(soccerCountryList)){
                        continue;
                    }
                    SoccerCountries soccerCountries = new SoccerCountries();
                    soccerCountries.setName(SoccerResponseUtil.objectToStr(jsonObject.get("code")));
                    soccerCountries.setCode(SoccerResponseUtil.objectToStr(jsonObject.get("name")));
                    soccerCountries.setFlag(SoccerResponseUtil.objectToStr(jsonObject.get("flag")));
                    soccerCountriesMapper.insert(soccerCountries);
                }
            }
        }
        return new FebsResponse().success().data(jsonResponse);
    }

    @Override
    public FebsResponse leagues(LeaguesApiDto leaguesApiDto) {
        HttpResponse<String> httpResponse = null;
        int season = ObjectUtil.isEmpty(leaguesApiDto.getSeason()) ? DateUtil.date().year() : leaguesApiDto.getSeason();
        String current = ObjectUtil.isEmpty(leaguesApiDto.getCurrent()) ? "true" : leaguesApiDto.getCurrent();
        try {
            /**
             *  https://v3.football.api-sports.io/leagues?season=2023¤t=true
             */
            httpResponse = Unirest.get(" https://v3.football.api-sports.io/leagues")
                    .header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
                    .header("x-rapidapi-host", "v3.football.api-sports.io")
                    .queryString("season",season)
                    .queryString("current",current)
                    .asString();
        } catch (UnirestException e) {
            e.printStackTrace();
        }

        LeaguesResponse leaguesResponse = SoccerResponseUtil.getLeaguesResponse(httpResponse);
        if(ObjectUtil.isNotEmpty(leaguesResponse)){
            List<LeaguesInfo> responses = leaguesResponse.getResponse();
            if(CollUtil.isNotEmpty(responses)){
                for(LeaguesInfo leaguesInfo : responses){

                    SoccerLeagues soccerLeagues = new SoccerLeagues();
                    Integer leaguesId = SoccerResponseUtil.objectToInteger(leaguesInfo.getLeague().getId());
                    List<SoccerLeagues> soccerLeaguesList = soccerLeaguesMapper.selectList(new QueryWrapper<SoccerLeagues>().eq("leagues_id", leaguesId));
                    if(CollUtil.isNotEmpty(soccerLeaguesList)){
                        continue;
                    }
                    soccerLeagues.setLeaguesId(SoccerResponseUtil.objectToInteger(leaguesInfo.getLeague().getId()));
                    soccerLeagues.setLeaguesName(SoccerResponseUtil.objectToStr(leaguesInfo.getLeague().getName()));
                    soccerLeagues.setLeaguesType(SoccerResponseUtil.objectToStr(leaguesInfo.getLeague().getType()));
                    soccerLeagues.setLeaguesLogo(SoccerResponseUtil.objectToStr(leaguesInfo.getLeague().getLogo()));

                    soccerLeagues.setCountryName(SoccerResponseUtil.objectToStr(leaguesInfo.getCountry().getName()));
                    soccerLeagues.setCountryCode(SoccerResponseUtil.objectToStr(leaguesInfo.getCountry().getCode()));
                    soccerLeagues.setCountryFlag(SoccerResponseUtil.objectToStr(leaguesInfo.getCountry().getFlag()));
                    soccerLeaguesMapper.insert(soccerLeagues);
                }
            }
        }

        return new FebsResponse().success().data(leaguesResponse);
    }

    @Override
    public FebsResponse timezone() {
        HttpResponse<String> httpResponse = null;
        try {
            httpResponse = Unirest.get("https://v3.football.api-sports.io/timezone")
                    .header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
                    .header("x-rapidapi-host", "v3.football.api-sports.io").asString();
        } catch (UnirestException e) {
            e.printStackTrace();
        }

        JsonResponse jsonResponse = SoccerResponseUtil.getJsonResponse(httpResponse);
        if(ObjectUtil.isNotEmpty(jsonResponse)){
            List<Object> responses = jsonResponse.getResponse();
            if(CollUtil.isNotEmpty(jsonResponse.getResponse())){
                for(Object timezoneName : responses){
                    SoccerTimezone soccerTimezone = new SoccerTimezone();
                    soccerTimezone.setTimezoneName(SoccerResponseUtil.objectToStr(timezoneName));
                    soccerTimezoneMapper.insert(soccerTimezone);
                }
            }
        }

        return new FebsResponse().success().data(jsonResponse);
    }

    @Override
    public FebsResponse seasons() {
        HttpResponse<String> httpResponse = null;
        /**
         * https://v3.football.api-sports.io/leagues/seasons
         */
        try {
            httpResponse = Unirest.get("https://v3.football.api-sports.io/leagues/seasons")
                    .header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
                    .header("x-rapidapi-host", "v3.football.api-sports.io").asString();
        } catch (UnirestException e) {
            e.printStackTrace();
        }

        JsonResponse jsonResponse = SoccerResponseUtil.getJsonResponse(httpResponse);
        if(ObjectUtil.isNotEmpty(jsonResponse)){
            List<Object> responses = jsonResponse.getResponse();
            if(CollUtil.isNotEmpty(jsonResponse.getResponse())){
                for(Object seasonsName : responses){
                    SoccerLeaguesSeasons soccerLeaguesSeasons = new SoccerLeaguesSeasons();
                    soccerLeaguesSeasons.setSeasonsName(SoccerResponseUtil.objectToStr(seasonsName));
                    soccerLeaguesSeasonsMapper.insert(soccerLeaguesSeasons);
                }
            }
        }
        return new FebsResponse().success().data(jsonResponse);
    }

    @Override
    public FebsResponse teams(TeamsApiDto teamsApiDto) {
        HttpResponse<String> httpResponse = null;
        String country = teamsApiDto.getCountry();

        try {
            /**
             *  https://v3.football.api-sports.io/teams
             */
            httpResponse = Unirest.get(" https://v3.football.api-sports.io/teams")
                    .header("x-rapidapi-key", "87f8d87d629d1704ba49622cb978eb81")
                    .header("x-rapidapi-host", "v3.football.api-sports.io")
                    .queryString("country",country)
                    .asString();
        } catch (UnirestException e) {
            e.printStackTrace();
        }

        TeamsInfoResponse teamsInfoResponse = SoccerResponseUtil.getTeamsInfoResponse(httpResponse);
        if(ObjectUtil.isNotEmpty(teamsInfoResponse)){
            List<TeamsInfo> responses = teamsInfoResponse.getResponse();
            if(CollUtil.isNotEmpty(responses)){
                for(TeamsInfo teamsInfo : responses){

                    Team team = teamsInfo.getTeam();
                    if(ObjectUtil.isNotEmpty(team)){
                        Integer teamId = team.getId();
                        List<SoccerTeam> soccerTeams = soccerTeamMapper.selectList(new QueryWrapper<SoccerTeam>().eq("team_id", teamId));
                        if(CollUtil.isEmpty(soccerTeams)){
                            SoccerTeam soccerTeam = new SoccerTeam();
                            soccerTeam.setTeamId(team.getId());
                            soccerTeam.setName(team.getName());
                            soccerTeam.setCode(team.getCode());
                            soccerTeam.setCountry(team.getCountry());
                            soccerTeam.setFounded(team.getFounded());
                            soccerTeam.setNational(team.getNational());
                            soccerTeam.setLogo(team.getLogo());
                            soccerTeamMapper.insert(soccerTeam);
                        }
                    }

                    Venue venue = teamsInfo.getVenue();
                    if(ObjectUtil.isNotEmpty(venue)){
                        Integer venueId = venue.getId();
                        List<SoccerVenue> soccerVenues = soccerVenueMapper.selectList(new QueryWrapper<SoccerVenue>().eq("venue_id", venueId));
                        if(CollUtil.isEmpty(soccerVenues)){
                            SoccerVenue soccerVenue = new SoccerVenue();
                            soccerVenue.setVenueId(venue.getId());
                            soccerVenue.setName(venue.getName());
                            soccerVenue.setAddress(venue.getAddress());
                            soccerVenue.setCity(venue.getCity());
                            soccerVenue.setCapacity(venue.getCapacity());
                            soccerVenue.setSurface(venue.getSurface());
                            soccerVenue.setImage(venue.getImage());
                            soccerVenueMapper.insert(soccerVenue);
                        }
                    }
                }
            }
        }
        return new FebsResponse().success().data(teamsInfoResponse);
    }

    public static void main(String[] args) {
        String str = "{\n" +
                "    \"get\": \"leagues\",\n" +
                "    \"parameters\": {\n" +
                "        \"season\": \"2008\",\n" +
                "        \"country\": \"World\"\n" +
                "    },\n" +
                "    \"errors\": [],\n" +
                "    \"results\": 1,\n" +
                "    \"paging\": {\n" +
                "        \"current\": 1,\n" +
                "        \"total\": 1\n" +
                "    },\n" +
                "    \"response\": [\n" +
                "        {\n" +
                "            \"league\": {\n" +
                "                \"id\": 4,\n" +
                "                \"name\": \"Euro Championship\",\n" +
                "                \"type\": \"Cup\",\n" +
                "                \"logo\": \"https://media.api-sports.io/football/leagues/4.png\"\n" +
                "            },\n" +
                "            \"country\": {\n" +
                "                \"name\": \"World\",\n" +
                "                \"code\": null,\n" +
                "                \"flag\": null\n" +
                "            },\n" +
                "            \"seasons\": [\n" +
                "                {\n" +
                "                    \"year\": 2008,\n" +
                "                    \"start\": \"2008-06-07\",\n" +
                "                    \"end\": \"2008-06-29\",\n" +
                "                    \"current\": false,\n" +
                "                    \"coverage\": {\n" +
                "                        \"fixtures\": {\n" +
                "                            \"events\": true,\n" +
                "                            \"lineups\": true,\n" +
                "                            \"statistics_fixtures\": false,\n" +
                "                            \"statistics_players\": false\n" +
                "                        },\n" +
                "                        \"standings\": false,\n" +
                "                        \"players\": true,\n" +
                "                        \"top_scorers\": true,\n" +
                "                        \"top_assists\": true,\n" +
                "                        \"top_cards\": true,\n" +
                "                        \"injuries\": false,\n" +
                "                        \"predictions\": true,\n" +
                "                        \"odds\": false\n" +
                "                    }\n" +
                "                }\n" +
                "            ]\n" +
                "        }\n" +
                "    ]\n" +
                "}";
        LeaguesResponse leaguesResponse = new LeaguesResponse();
        ObjectMapper mapper = new ObjectMapper();
        try {
            leaguesResponse = mapper.readValue(str, LeaguesResponse.class);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(leaguesResponse);
    }
}