package fic

import (
	"bufio"
	"crypto/sha1"
	"encoding/hex"
	"errors"
	"io"
	"os"
	"path"
	"strings"
)

var FilesDir string
var OptionalDigest bool

type EFile struct {
	Id         int64 `json:"id"`
	origin     string
	Path       string `json:"path"`
	IdExercice int64  `json:"idExercice"`
	Name       string `json:"name"`
	Checksum   []byte `json:"checksum"`
	Size       int64  `json:"size"`
}

func GetFiles() ([]EFile, error) {
	if rows, err := DBQuery("SELECT id_file, id_exercice, origin, path, name, sha1, size FROM exercice_files"); err != nil {
		return nil, err
	} else {
		defer rows.Close()

		var files = make([]EFile, 0)
		for rows.Next() {
			var f EFile
			if err := rows.Scan(&f.Id, &f.IdExercice, &f.origin, &f.Path, &f.Name, &f.Checksum, &f.Size); err != nil {
				return nil, err
			}
			files = append(files, f)
		}
		if err := rows.Err(); err != nil {
			return nil, err
		}

		return files, nil
	}
}

func (e Exercice) GetFiles() ([]EFile, error) {
	if rows, err := DBQuery("SELECT id_file, origin, path, name, sha1, size FROM exercice_files WHERE id_exercice = ?", e.Id); err != nil {
		return nil, err
	} else {
		defer rows.Close()

		var files = make([]EFile, 0)
		for rows.Next() {
			var f EFile
			f.IdExercice = e.Id
			if err := rows.Scan(&f.Id, &f.origin, &f.Path, &f.Name, &f.Checksum, &f.Size); err != nil {
				return nil, err
			}
			files = append(files, f)
		}
		if err := rows.Err(); err != nil {
			return nil, err
		}

		return files, nil
	}
}

func (e Exercice) ImportFile(filePath string, origin string, digest []byte) (interface{}, error) {
	if digest == nil && !OptionalDigest {
		return EFile{}, errors.New("No digest given.")
	} else if fi, err := os.Stat(filePath); err != nil {
		return EFile{}, err
	} else if fd, err := os.Open(filePath); err != nil {
		return EFile{}, err
	} else {
		defer fd.Close()

		reader := bufio.NewReader(fd)
		hash := sha1.New()
		if _, err := io.Copy(hash, reader); err != nil {
			return EFile{}, err
		}
		result := hash.Sum(nil)

		if len(digest) != len(result) {
			return EFile{}, errors.New("Digests doesn't match: calculated: " + hex.EncodeToString(result) + " vs. given: " + hex.EncodeToString(digest))
		}

		for k := range result {
			if result[k] != digest[k] {
				return EFile{}, errors.New("Digests doesn't match: calculated: " + hex.EncodeToString(result) + " vs. given: " + hex.EncodeToString(digest))
			}
		}

		return e.AddFile(strings.TrimPrefix(filePath, FilesDir), origin, path.Base(filePath), result, fi.Size())
	}
}

func (e Exercice) AddFile(path string, origin string, name string, checksum []byte, size int64) (EFile, error) {
	if res, err := DBExec("INSERT INTO exercice_files (id_exercice, origin, path, name, sha1, size) VALUES (?, ?, ?, ?, ?, ?)", e.Id, origin, path, name, checksum, size); err != nil {
		return EFile{}, err
	} else if fid, err := res.LastInsertId(); err != nil {
		return EFile{}, err
	} else {
		return EFile{fid, origin, path, e.Id, name, checksum, size}, nil
	}
}

func (f EFile) Update() (int64, error) {
	if res, err := DBExec("UPDATE exercice_files SET id_exercice = ?, origin = ?, path = ?, name = ?, sha1 = ?, size = ? WHERE id_file = ?", f.IdExercice, f.origin, f.Path, f.Name, f.Checksum, f.Size, f.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (f EFile) Delete() (int64, error) {
	if res, err := DBExec("DELETE FROM exercice_files WHERE id_file = ?", f.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (f EFile) GetOrigin() (string) {
	return f.origin
}