package storage

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/buger/jsonparser"
)

type One struct {
	ID       string   `json:"id"`
	Question Question `json:"q"`
	Answers  []Answer `json:"a"`
}

func (one *One) UnmarshalJSON(b []byte) error {
	if b, _, _, err := jsonparser.Get(b, "q"); err == jsonparser.KeyPathNotFoundError {
	} else if err != nil {
		return fmt.Errorf("failed to find question: %v: %q", err, b)
	} else if err := json.Unmarshal(b, &one.Question); err != nil {
		if err := json.Unmarshal([]byte(fmt.Sprintf("%q", b)), &one.Question); err != nil {
			return fmt.Errorf("failed to parse question from obj: %v: %q", err, b)
		}
	}

	if b, _, _, err := jsonparser.Get(b, "a"); err == jsonparser.KeyPathNotFoundError {
	} else if err != nil {
		return fmt.Errorf("failed to find answers: %v: %q", err, b)
	} else if err := json.Unmarshal(b, &one.Answers); err != nil {
		return fmt.Errorf("failed to parse answers: %v: %q", err, b)
	}

	if id, err := jsonparser.GetString(b, "id"); err != nil && err != jsonparser.KeyPathNotFoundError {
		return fmt.Errorf("failed to parse id: %v: %q", err, b)
	} else {
		one.ID = id
	}

	return nil
}

func (one *One) FillIDs() {
	if one.ID == "" {
		one.ID = NewID()
	}
	if one.Question.ID == "" {
		one.Question.ID = NewID()
	}
	for i := range one.Answers {
		if one.Answers[i].ID == "" {
			one.Answers[i].ID = NewID()
		}
	}
}

func (one One) Check(two One) bool {
	if !one.CheckQuestion(two) {
		log.Println("question mismatch")
		return false
	}
	if !one.CheckAnswers(two) {
		log.Println("answer mismatch")
		return false
	}
	return true
}

func (one One) CheckQuestion(two One) bool {
	log.Println(one.Question)
	log.Println(two.Question)
	log.Println(one.Question == (Question{}))
	log.Println(two.Question == (Question{}))
	log.Println(one.Question.Equals(two.Question.Pair))
	return one.Question == (Question{}) || two.Question == (Question{}) || one.Question.Equals(two.Question.Pair)
}

func (one One) CheckAnswers(two One) bool {
	log.Println(len(one.Answers), one.Answers)
	log.Println(len(two.Answers), two.Answers)
	if len(two.Answers) == 0 {
		return false
	}
	for _, answer := range two.Answers {
		log.Printf("%+v %s %v", answer, "with id", answer.ID)
		oanswer := one.GetAnswer(answer.ID)
		log.Println(" ", oanswer)
		if oanswer == (Answer{}) {
			return false
		}
		if !oanswer.Right {
			return false
		}
	}
	return true
}

func (one One) GetAnswer(id string) Answer {
	for _, answer := range one.Answers {
		log.Println(" ", answer, "==", id)
		if answer.ID == id {
			return answer
		}
	}
	return Answer{}
}

func (one One) HasSolution() bool {
	for i := range one.Answers {
		if one.Answers[i].Right {
			return true
		}
	}
	return false
}