package restutility

import (
//	"fmt"
	"errors"
//	"os"
	"time"
	"crypto/sha256"
	"crypto/rand"
	"encoding/hex"
	"strings"
	"github.com/dgrijalva/jwt-go"
//	"github.com/SermoDigital/jose/jwt"
)

const OneDay  = time.Hour*24
const OneWeek = OneDay*7
const saltSize = 32
const appName  = "korisnicki-centar"
const secret   = "korisnicki-centar-api"

type Token struct {
	TokenString string `json:"token"`
}

type TokenClaims struct {
	Username string `json:"username"`
	Role string     `json:"role"`
	jwt.StandardClaims
}

type CredentialsStruct struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

func generateSalt() (string, error) {
	salt := ""
	
	rawsalt := make([]byte, saltSize)
	_, err := rand.Read(rawsalt)
	if err != nil {
		return "", err
	}
	salt = hex.EncodeToString(rawsalt)
	return salt, nil
}

func hashMessage(message string, presalt string) (string, string, error) {
	hash, salt := "", ""
	var err error

	// chech if message is presalted
	if presalt == "" {
		salt, err = generateSalt()
		if err != nil {
			return "", "", err
		}
	} else {
		salt = presalt
	}

	// convert strings to raw byte slices
	rawmessage := []byte(message)
	rawsalt, err := hex.DecodeString(salt)
	if err != nil {
		return "", "", err
	}
	rawdata := make([]byte, len(rawmessage) + len(rawsalt))
	rawdata = append(rawdata, rawmessage...)
	rawdata = append(rawdata, rawsalt...)

	// hash message + salt
	hasher := sha256.New()
	hasher.Write(rawdata)
	rawhash := hasher.Sum(nil)
	hash = hex.EncodeToString(rawhash)
	return hash, salt, nil
}

func issueAPIToken(username, role string) (Token, error) {
	var apiToken Token
	var err error

	if err != nil {
		return Token{}, err
	}

	claims := TokenClaims{
		username,
		role,
		jwt.StandardClaims{
			ExpiresAt: (time.Now().Add(OneWeek)).Unix(),
			Issuer:    appName,
		},
	}

	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	apiToken.TokenString, err = jwtToken.SignedString([]byte(secret))
	if err != nil {
		return Token{}, err
	}
	return apiToken, nil
}

func refreshAPIToken(tokenString string) (Token, error) {
	var newToken Token
	tokenString = strings.TrimPrefix(tokenString, "Bearer ")
	token, err := parseTokenFunc(tokenString)
	if err != nil {
		return Token{}, err
	}

	// type assertion
	claims, ok := token.Claims.(*TokenClaims)
	if !ok || !token.Valid {
		return Token{}, errors.New("token is not valid")
	}

	claims.ExpiresAt = (time.Now().Add(OneWeek)).Unix()
	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

	newToken.TokenString, err = jwtToken.SignedString([]byte(secret))
	if err != nil {
		return Token{}, err
	}

	return newToken, nil
}

func parseAPIToken(tokenString string) (*TokenClaims, error) {
	if ok := strings.HasPrefix(tokenString, "Bearer"); ok {
		tokenString = strings.TrimPrefix(tokenString, "Bearer ")
	} else {
		return &TokenClaims{}, errors.New("Authorization header is incomplete")
	}

	token, err := parseTokenFunc(tokenString)
	if err != nil {
		return &TokenClaims{}, err
	}

	// type assertion
	claims, ok := token.Claims.(*TokenClaims)
	if !ok || !token.Valid {
		return &TokenClaims{}, errors.New("token is not valid")
	}
	return claims, nil
}

func parseTokenFunc(tokenString string) (*jwt.Token, error) {
	token, err := jwt.ParseWithClaims(tokenString,
		&TokenClaims{},
		func(token *jwt.Token) (interface{}, error) {
			return []byte(secret), nil
		},
	)
	return token, err
}

func authMinRegReq(uname, pword string) (bool, error) {
	return true, nil
}