package internal

import (
	"encoding/json"
	"time"

	"github.com/creasty/defaults"
	log "github.com/sirupsen/logrus"
)

// User ...
type User struct {
	Username  string
	Password  string
	CreatedAt time.Time

	Recovery string `default:"auto"`

	Tokens []string `default:"[]"`
}

// Token ...
type Token struct {
	Signature string
	Value     string
	UserAgent string
	CreatedAt time.Time
	ExpiresAt time.Time
}

// URL  ...
type URL struct {
	URL       string
	CrawledAt time.Time
	ExpiresAt time.Time

	hash string
}

func LoadToken(data []byte) (token *Token, err error) {
	token = &Token{}
	if err := defaults.Set(token); err != nil {
		return nil, err
	}

	if err = json.Unmarshal(data, &token); err != nil {
		return nil, err
	}

	return
}

func (t *Token) Bytes() ([]byte, error) {
	data, err := json.Marshal(t)
	if err != nil {
		return nil, err
	}
	return data, nil
}

// NewUser ...
func NewUser() *User {
	user := &User{}
	if err := defaults.Set(user); err != nil {
		log.WithError(err).Error("error creating new user object")
	}
	return user
}

func LoadUser(data []byte) (user *User, err error) {
	user = &User{}
	if err := defaults.Set(user); err != nil {
		return nil, err
	}

	if err = json.Unmarshal(data, &user); err != nil {
		return nil, err
	}

	return
}

func (u *User) String() string {
	return u.Username
}

// HasToken will add a token to a user if it doesn't exist already
func (u *User) AddToken(token *Token) {
	if !u.HasToken(token.Signature) {
		u.Tokens = append(u.Tokens, token.Signature)
	}
}

// HasToken will compare a token value with stored tokens
func (u *User) HasToken(token string) bool {
	for _, t := range u.Tokens {
		if t == token {
			return true
		}
	}
	return false
}

func (u *User) Bytes() ([]byte, error) {
	data, err := json.Marshal(u)
	if err != nil {
		return nil, err
	}
	return data, nil
}

// NewURL ...
func NewURL(url string) *URL {
	u := &URL{URL: url}
	if err := defaults.Set(u); err != nil {
		log.WithError(err).Error("error creating new URI object")
	}
	return u
}

func LoadURL(data []byte) (u *URL, err error) {
	u = &URL{}
	if err := defaults.Set(u); err != nil {
		return nil, err
	}

	if err = json.Unmarshal(data, &u); err != nil {
		return nil, err
	}

	return
}

func (u *URL) Hash() string {
	if u.hash != "" {
		return u.hash
	}

	u.hash = HashURL(u.String())

	return u.hash
}

func (u *URL) String() string {
	return u.URL
}

func (u *URL) Bytes() ([]byte, error) {
	data, err := json.Marshal(u)
	if err != nil {
		return nil, err
	}
	return data, nil
}