package fic

import (
	"crypto/sha512"
	"time"
)

type Key struct {
	Id         int64  `json:"id"`
	IdExercice int64  `json:"idExercice"`
	Type       string `json:"type"`
	Value      []byte `json:"value"`
}

func (e Exercice) GetKeys() ([]Key, error) {
	if rows, err := DBQuery("SELECT id_key, id_exercice, type, value FROM exercice_keys WHERE id_exercice = ?", e.Id); err != nil {
		return nil, err
	} else {
		defer rows.Close()

		var keys = make([]Key, 0)
		for rows.Next() {
			var k Key
			k.IdExercice = e.Id

			if err := rows.Scan(&k.Id, &k.IdExercice, &k.Type, &k.Value); err != nil {
				return nil, err
			}
			keys = append(keys, k)
		}
		if err := rows.Err(); err != nil {
			return nil, err
		}

		return keys, nil
	}
}

func getHashedKey(raw_value string) []byte {
	hash := sha512.Sum512([]byte(raw_value))
	return hash[:]
}

func (e Exercice) AddRawKey(name string, raw_value string) (Key, error) {
	return e.AddKey(name, getHashedKey(raw_value))
}

func (e Exercice) AddKey(name string, value []byte) (Key, error) {
	if res, err := DBExec("INSERT INTO exercice_keys (id_exercice, type, value) VALUES (?, ?, ?)", e.Id, name, value); err != nil {
		return Key{}, err
	} else if kid, err := res.LastInsertId(); err != nil {
		return Key{}, err
	} else {
		return Key{kid, e.Id, name, value}, nil
	}
}

func (k Key) Update() (int64, error) {
	if res, err := DBExec("UPDATE exercice_keys SET id_exercice = ?, type = ?, value = ? WHERE id_key = ?", k.IdExercice, k.Type, k.Value, k.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (k Key) Delete() (int64, error) {
	if res, err := DBExec("DELETE FROM exercice_keys WHERE id_key = ?", k.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (k Key) Check(val string) bool {
	hash := getHashedKey(val)
	if len(k.Value) != len(hash) {
		return false
	}

	for i := range hash {
		if k.Value[i] != hash[i] {
			return false
		}
	}

	return true
}

func (k Key) FoundBy(t Team) {
	DBExec("INSERT INTO key_found (id_key, id_team, time) VALUES (?, ?, ?)", k.Id, t.Id, time.Now())
}