package app.controllers.auth;

import app.annotations.enums.AuthMethod;
import app.annotations.exceptions.InvalidCookie;
import app.annotations.exceptions.NeedCookie;
import app.annotations.interfaces.CheckWebAccess;
import app.services.db.DiscordAuthService;
import app.services.steam.SteamSignIn;
import app.services.steam.SteamWebApi;
import app.utils.SaltedCookie;
import app.utils.SteamIDConverter;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

@RestController
@RequestMapping("/api/auth")
public class AuthSteamController {
    private SteamSignIn steamSignIn;
    private SaltedCookie saltedCookie;
    private SteamWebApi steamWebApi;
    private DiscordAuthService discordAuthService;

    @Autowired
    public AuthSteamController(SteamSignIn steamSignIn, SaltedCookie saltedCookie, SteamWebApi steamWebApi, DiscordAuthService discordAuthService){
        this.steamSignIn = steamSignIn;
        this.saltedCookie = saltedCookie;
        this.steamWebApi = steamWebApi;
        this.discordAuthService = discordAuthService;
    }

    @GetMapping("login")
    public ResponseEntity<Void> Login(){
        return steamSignIn.ConstructURLAndRedirect();
    }

    @GetMapping("logout")
    public ResponseEntity<?> Logout(HttpServletResponse response){
        Cookie cookie_steam64 = new Cookie("steam64","");
        cookie_steam64.setMaxAge(0);
        cookie_steam64.setPath("/");
        cookie_steam64.setDomain("tf2.pblr-nyk.pro");
        response.addCookie(cookie_steam64);
        Cookie cookie_steam64_secured = new Cookie("steam64_secured", "");
        cookie_steam64_secured.setMaxAge(0);
        cookie_steam64_secured.setDomain("tf2.pblr-nyk.pro");
        cookie_steam64_secured.setPath("/");
        response.addCookie(cookie_steam64_secured);
        return ResponseEntity.status(HttpStatus.FOUND).
                header("Location", "/")
                .build();
    }

    @GetMapping("processlogin")
    public ResponseEntity<?> ProcessLogin(@RequestParam Map<String, String> auth_result, HttpServletResponse response){
        System.out.println(auth_result);
        Long steam64 = steamSignIn.ValidateResults(auth_result);
        if(steam64 == null){
            return new ResponseEntity<>("returned steam is not valid",HttpStatus.FORBIDDEN);
        }

        Cookie cookie_steam64 = new Cookie("steam64", steam64.toString());
        cookie_steam64.setPath("/");
        cookie_steam64.setDomain("tf2.pblr-nyk.pro");
        response.addCookie(cookie_steam64);
        Cookie cookie_steam64_secured = new Cookie("steam64_secured", saltedCookie.Hashed(steam64.toString()));
        cookie_steam64_secured.setPath("/");
        cookie_steam64_secured.setDomain("tf2.pblr-nyk.pro");
        response.addCookie(cookie_steam64_secured);

        return ResponseEntity.status(HttpStatus.FOUND).
                header("Location", "/")
                .build();
    }

    @GetMapping("steam")
    public ResponseEntity aboutMe(@CookieValue(value = "steam64", defaultValue = "") String steam64,
                                  @CookieValue(value = "steam64_secured", defaultValue = "") String steam64_secured) {
        if (steam64.isEmpty() || steam64_secured.isEmpty()) {
            throw new NeedCookie();
        }

        if (!saltedCookie.Validate(steam64, steam64_secured)) {
            throw new InvalidCookie();
        }

        return new ResponseEntity(steamWebApi.getSteamData(SteamIDConverter.getSteamID(steam64).steam64), HttpStatus.OK);
    }

    @GetMapping("steam/discord")
    public ResponseEntity<String> getDiscordID(@CookieValue(value = "steam64", defaultValue = "") String steam64,
                                               @CookieValue(value = "steam64_secured", defaultValue = "") String steam64_secured) {
        if (steam64.isEmpty() || steam64_secured.isEmpty()) {
            throw new NeedCookie();
        }

        if (!saltedCookie.Validate(steam64, steam64_secured)) {
            throw new InvalidCookie();
        }

        String discord_id = discordAuthService.getDiscordIDofSteamID(SteamIDConverter.getSteamID(steam64));
        if (discord_id != null) return new ResponseEntity(discord_id, HttpStatus.OK);
        else return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }
}