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.entity.*;
import cc.mrbird.febs.dapp.soccer.mapper.SoccerCountriesMapper;
import cc.mrbird.febs.dapp.soccer.mapper.SoccerLeaguesMapper;
import cc.mrbird.febs.dapp.soccer.mapper.SoccerTimezoneMapper;
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;

    @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);
    }

    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);
    }
}