package document

import (
	"errors"
	"fmt"
	"io"
	"mime"
	"net/http"
	"os"
	"time"

	web "git.to-net.rs/marko.tikvic/webutility"
)

// Document ...
type Document struct {
	ID               int64         `json:"id"`
	FileName         string        `json:"fileName"`
	Extension        string        `json:"extension"`
	ContentType      string        `json:"contentType"`
	Size             int64         `json:"fileSize"`
	UploadedBy       string        `json:"uploadedBy"`
	LastModifiedBy   string        `json:"lastModifiedBy"`
	TimeUploaded     int64         `json:"timeUploaded"`
	TimeLastModified int64         `json:"timeLastModified"`
	RoleAccessLevel  int64         `json:"accessLevel"`
	Description      string        `json:"description"`
	Download         *DownloadLink `json:"download"`
	Path             string        `json:"-"`
	directory        string
	data             []byte
}

// OpenFileAsDocument ...
func OpenFileAsDocument(path string) (*Document, error) {
	d := &Document{Path: path}

	f, err := os.Open(d.Path)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	stats, err := f.Stat()
	if err != nil {
		return nil, err
	}

	d.FileName = stats.Name()
	d.Size = stats.Size()
	d.Extension = web.FileExtension(d.FileName)

	d.data = make([]byte, d.Size)
	if _, err = f.Read(d.data); err != nil {
		return nil, err
	}

	return d, err
}

// DownloadLink ...
type DownloadLink struct {
	Method string `json:"method"`
	URL    string `json:"url"`
}

// SetDownloadInfo ...
func (d *Document) SetDownloadInfo(method, url string) {
	d.Download = &DownloadLink{
		Method: method,
		URL:    url,
	}
}

// ServeDocument writes d's buffer to w and sets appropriate headers according to d's content type
// and downloadPrompt.
func ServeDocument(w http.ResponseWriter, d *Document, downloadPrompt bool) error {
	f, err := os.Open(d.Path)
	if err != nil {
		return err
	}
	defer f.Close()

	web.SetContentType(w, mime.TypeByExtension(d.Extension))
	web.SetResponseStatus(w, http.StatusOK)
	if downloadPrompt {
		w.Header().Set("Content-Disposition", "attachment; filename="+d.FileName)
	}

	buf := make([]byte, d.Size)
	if _, err := f.Read(buf); err != nil {
		return err
	}

	w.Header().Set("Content-Length", fmt.Sprintf("%d", d.Size))
	web.WriteResponse(w, buf)

	return nil
}

// ParseDocument ...
func ParseDocument(req *http.Request) (doc *Document, err error) {
	req.ParseMultipartForm(32 << 20)
	file, fheader, err := req.FormFile("document")
	if err != nil {
		return doc, err
	}

	claims, _ := web.GetTokenClaims(req)
	owner := claims.Username

	fname := fheader.Filename

	fsize := fheader.Size
	ftype := fmt.Sprintf("%v", fheader.Header["Content-Type"][0])

	fextn := web.FileExtension(fname)
	if fextn == "" {
		return doc, errors.New("invalid extension")
	}

	doc = new(Document)

	doc.FileName = fname
	doc.Size = fsize
	doc.ContentType = ftype
	doc.Extension = "." + fextn

	t := time.Now().Unix()
	doc.TimeUploaded = t
	doc.TimeLastModified = t

	doc.UploadedBy = owner
	doc.LastModifiedBy = owner
	doc.RoleAccessLevel = 0

	doc.data = make([]byte, doc.Size)
	if _, err = io.ReadFull(file, doc.data); err != nil {
		return doc, err
	}

	return doc, nil
}

// SaveToFile ...
func (d *Document) SaveToFile(path string) (f *os.File, err error) {
	d.Path = path

	if web.FileExists(path) {
		err = fmt.Errorf("file %s alredy exists", path)
		return nil, err
	}

	if parentDir := web.DirectoryFromPath(path); parentDir != "" {
		if err = os.MkdirAll(parentDir, os.ModePerm); err != nil {
			if !os.IsExist(err) {
				return nil, err
			}
		}
	}

	if f, err = os.Create(path); err != nil {
		return nil, err
	}

	if _, err = f.Write(d.data); err != nil {
		f.Close()
		d.DeleteFile()
		return nil, err
	}
	f.Close()

	return f, nil
}

func DeleteDocuments(docs []*Document) error {
	for _, d := range docs {
		if d == nil {
			continue
		}
		if err := d.DeleteFile(); err != nil {
			return err
		}
	}
	return nil
}

// DeleteFile ...
func (d *Document) DeleteFile() error {
	return os.Remove(d.Path)
}