package com.controllers;

import com.DAO.newDAO.CharacterRepository;
import com.DAO.newDAO.SpellsRepository;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.models.Kostyly;
import com.models.entity.CharactersEntity;
import com.models.entity.SpellsEntity;
import com.models.entity.UsersEntity;
import com.services.UserService;
//import com.sun.org.apache.xpath.internal.operations.String;
import javax.validation.constraints.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;

@Controller
public class RestController {

    private UsersEntity user;
    private Kostyly kostyly;

    private final UserService userService;

    @Autowired
    public CharacterRepository characterRepository;

    @Autowired
    public SpellsRepository spellsRepository;

    @Autowired
    public RestController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/")
    public String redirectToGreeting() {
        return "redirect:/greeting";
    }

    @GetMapping("/greeting")
    public String greetingForm(Model model) {
        model.addAttribute("reg", new UsersEntity());
        return "index";
    }

    @GetMapping("/main_page")
    public String mainPage() {
        return "user_main_page";
    }

    @PostMapping("/greeting")
    public String greetingSubmit(@ModelAttribute UsersEntity userR) {
        System.out.println(userR);

        UsersEntity userByLoginAndPassword =
                userService.getUserByLoginAndPassword(
                        userR.getLogin(),
                        userR.getPassword()
                );

        System.out.println(userByLoginAndPassword);
        if (userByLoginAndPassword == null) {
            return "redirect:/greeting";
        }
        user = userByLoginAndPassword;
        return "redirect:/character_menu";
    }

    @GetMapping("/reg")
    public String registrationForm(Model model) {
        model.addAttribute("userR", new UsersEntity());
        return "registration";
    }

    @PostMapping("/reg")
    public String registrationSubmit(@ModelAttribute UsersEntity userR) {
        if (userService.checkLogin(userR.getLogin())) {
            userService.saveUser(userR);
            return "redirect:/greeting";
        } else {
            return "redirect:/reg";
        }
    }

    @GetMapping("/character_menu")
    public String characterMenuForm(HttpServletResponse httpServletResponse, Model model) throws IOException {
        if (user != null) {
            model.addAttribute("characterId", new Kostyly());
            ObjectMapper objectMapper = new ObjectMapper();
            String jsonStr = objectMapper.writeValueAsString(user.getCharacters());
            httpServletResponse.addCookie(new Cookie("characters", URLEncoder.encode(jsonStr, "UTF-8")));
            return "character_menu";
        } else
            return "redirect:/greeting";
    }

    @PostMapping("/character_menu")
    public String characterMenuSubmit(@ModelAttribute Kostyly characterId) {
        System.out.println(characterId.getCharacterId());
        kostyly = characterId;
        return "redirect:/home";
    }

    @GetMapping("/home")
    public String homeForm(HttpServletResponse httpServletResponse, Model model) throws IOException {
        model.addAttribute("characterId", new Kostyly());
        if (kostyly != null) {
            CharactersEntity charactersEntity = null;
            for (int i = 0; i < user.getCharacters().size(); i++) {
                if (Integer.parseInt(kostyly.getCharacterId())
                        == user.getCharacters().get(i).getId()) {
                    charactersEntity = user.getCharacters().get(i);
                }
            }

            ObjectMapper objectMapper = new ObjectMapper();

            String jsonStr = objectMapper.writeValueAsString(charactersEntity);


                String jsonStr2 = objectMapper.writeValueAsString(charactersEntity.getSpells());

            String jsonStr3 = objectMapper.writeValueAsString(spellsRepository.findAll());

            httpServletResponse.addCookie(new Cookie("character", URLEncoder.encode(jsonStr, "UTF-8")));
            if (charactersEntity.getSpells() != null) {
                httpServletResponse.addCookie(new Cookie("spells", URLEncoder.encode(jsonStr2, "UTF-8")));
            }else {
                httpServletResponse.addCookie(new Cookie("spells", URLEncoder.encode("{}", "UTF-8")));
            }
            httpServletResponse.addCookie(new Cookie("allSpells", URLEncoder.encode(jsonStr3, "UTF-8")));
            return "home";
        } else
            return "redirect:/greeting";
    }

    @PostMapping("/home")
    public String homeSubmit(@ModelAttribute Kostyly characterId) {
        if (characterId.getTypeE().equals("addToCharacter")) {
            int sendCharacterId = Integer.parseInt(characterId.getCharacterId());
            System.out.println("sendCharacterId = " + sendCharacterId);
            int sendSpellsId = Integer.parseInt(characterId.getSpellId());
            System.out.println("sendSpellsId = " + sendSpellsId);
            List<SpellsEntity> spellsEntities =
                    spellsRepository.saveSpellInUser(sendCharacterId, sendSpellsId);

        } else if (characterId.getTypeE().equals("RemoveFromCharacter")) {
            spellsRepository.deleteSpellInUser(Integer.parseInt(characterId.getCharacterId()),
                    Integer.parseInt(characterId.getSpellId()));
        }

        String login = user.getLogin();
        String password = user.getPassword();

        UsersEntity userByLoginAndPassword =
                userService.getUserByLoginAndPassword(login, password);
        user = userByLoginAndPassword;
        return "redirect:/home";
    }

    @GetMapping("/create_character")
    public String characterForm(Model model) {
        model.addAttribute("character", new CharactersEntity());
        return "create_character";
    }

    @PostMapping("/create_character")
    public String characterSubmit(@ModelAttribute CharactersEntity character) {
        character.setUser(user);
        characterRepository.save(character);

        String login = user.getLogin();
        String password = user.getPassword();

        UsersEntity userByLoginAndPassword =
                userService.getUserByLoginAndPassword(login, password);
        user = userByLoginAndPassword;
        return "redirect:/home";
    }


    @GetMapping("/admin_menu")
    public String adminForm(HttpServletResponse httpServletResponse, Model model) throws JsonProcessingException, UnsupportedEncodingException {
        ObjectMapper objectMapper = new ObjectMapper();
        model.addAttribute("characterId", new Kostyly());
        String jsonStr1 = objectMapper.writeValueAsString(spellsRepository.findAll());
        String jsonStr2 = objectMapper.writeValueAsString(userService.getAllUsers());
        String jsonStr3 = objectMapper.writeValueAsString(characterRepository.findAll());

        httpServletResponse.addCookie(new Cookie("allUsers", URLEncoder.encode(jsonStr2, "UTF-8")));
        httpServletResponse.addCookie(new Cookie("allSpells", URLEncoder.encode(jsonStr1, "UTF-8")));
        httpServletResponse.addCookie(new Cookie("character", URLEncoder.encode(jsonStr3, "UTF-8")));

        return "admin_menu";
    }

    @PostMapping("/admin_menu")
    public String adminSubmit(@ModelAttribute Kostyly kostyly) {
        if (kostyly.getTypeE().equals("spell")) {
            List<SpellsEntity> byId = spellsRepository.findById(Integer.parseInt(kostyly.getCharacterId()));
            spellsRepository.delete(byId.get(0));
        } else if (kostyly.getTypeE().equals("user")) {
            userService.removeUser(Integer.parseInt(kostyly.getCharacterId()));
        } else if (kostyly.getTypeE().equals("character")) {
            List<CharactersEntity> byId = characterRepository.findById(Integer.parseInt(kostyly.getCharacterId()));
            this.characterRepository.delete(byId.get(0));
        }
        return "redirect:/admin_menu";
    }

    @GetMapping("/create_spell")
    public String SpellForm(Model model) {
        model.addAttribute("spell", new SpellsEntity());
        return "create_spell";
    }

    @PostMapping("/create_spell")
    public String spellSubmit(@ModelAttribute SpellsEntity spell) {
        spellsRepository.save(spell);
        return "redirect:/admin_menu";

    }

}