/*
goredo -- djb's redo implementation on pure Go
Copyright (C) 2020-2023 Sergey Matveev <stargrave@stargrave.org>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// Dependencies saver

package main

import (
	"bufio"
	"bytes"
	"encoding/hex"
	"errors"
	"io"
	"log"
	"os"
	"path"

	"go.cypherpunks.ru/recfile"
	"lukechampine.com/blake3"
)

var (
	DirPrefix string
	DepCwd    string

	ErrBadRecFormat = errors.New("invalid format of .rec")
)

func recfileWrite(fdDep io.StringWriter, fields ...recfile.Field) error {
	w := recfile.NewWriter(fdDep)
	if _, err := w.RecordStart(); err != nil {
		return err
	}
	if _, err := w.WriteFields(fields...); err != nil {
		return err
	}
	return nil
}

func ifcreate(fdDep *os.File, tgt string) error {
	tracef(CDebug, "ifcreate: %s <- %s", fdDep.Name(), tgt)
	return recfileWrite(
		fdDep,
		recfile.Field{Name: "Type", Value: DepTypeIfcreate},
		recfile.Field{Name: "Target", Value: tgt},
	)
}

func always(fdDep *os.File) error {
	tracef(CDebug, "always: %s", fdDep.Name())
	return recfileWrite(fdDep, recfile.Field{Name: "Type", Value: DepTypeAlways})
}

func stamp(fdDep, src *os.File) error {
	hsh, err := fileHash(src)
	if err != nil {
		return err
	}
	tracef(CDebug, "stamp: %s <- %s", fdDep.Name(), hex.EncodeToString(hsh))
	return recfileWrite(
		fdDep,
		recfile.Field{Name: "Type", Value: DepTypeStamp},
		recfile.Field{Name: "Hash", Value: hex.EncodeToString(hsh)},
	)
}

func fileHash(fd *os.File) ([]byte, error) {
	h := blake3.New(32, nil)
	if _, err := io.Copy(h, bufio.NewReader(fd)); err != nil {
		return nil, err
	}
	return h.Sum(nil), nil
}

func depWrite(fdDep *os.File, cwd string, tgt *Tgt, hsh []byte) error {
	tracef(CDebug, "ifchange: %s <- %s", fdDep.Name(), tgt)
	fd, err := os.Open(tgt.a)
	if err != nil {
		return ErrLine(err)
	}
	defer fd.Close()
	inode, isDir, err := inodeFromFileByFd(fd)
	if err != nil {
		return ErrLine(err)
	}
	if isDir {
		return nil
	}
	if hsh == nil {
		hsh, err = fileHash(fd)
		if err != nil {
			return ErrLine(err)
		}
	}
	fields := []recfile.Field{
		{Name: "Type", Value: DepTypeIfchange},
		{Name: "Target", Value: tgt.RelTo(cwd)},
		{Name: "Hash", Value: hex.EncodeToString(hsh)},
	}
	fields = append(fields, inode.RecfileFields()...)
	return recfileWrite(fdDep, fields...)
}

func depsWrite(fdDep *os.File, tgts []*Tgt) error {
	if fdDep == nil {
		tracef(CDebug, "no opened fdDep: %s", tgts)
		return nil
	}
	var err error
	var cwd string
	for _, tgt := range tgts {
		cwd = Cwd
		if DepCwd != "" && Cwd != DepCwd {
			cwd = DepCwd
		}
		tgtDir := path.Join(cwd, DirPrefix)
		if _, errStat := os.Stat(tgt.a); errStat == nil {
			err = ErrLine(depWrite(fdDep, tgtDir, tgt, nil))
		} else {
			tgtRel := tgt.RelTo(tgtDir)
			tracef(CDebug, "ifchange: %s <- %s (non-existing)", fdDep.Name(), tgtRel)
			fields := []recfile.Field{
				{Name: "Type", Value: DepTypeIfchange},
				{Name: "Target", Value: tgtRel},
			}
			inodeDummy := Inode{}
			fields = append(fields, inodeDummy.RecfileFields()...)
			err = ErrLine(recfileWrite(fdDep, fields...))
		}
		if err != nil {
			return err
		}
	}
	return nil
}

type DepInfoIfchange struct {
	tgt   *Tgt
	inode *Inode
	hash  []byte
}

type DepInfo struct {
	build     string
	always    bool
	stamp     []byte
	ifcreates []*Tgt
	ifchanges []DepInfoIfchange
}

func mustHexDecode(s string) []byte {
	b, err := hex.DecodeString(s)
	if err != nil {
		log.Fatal(err)
	}
	return b
}

var missingBuild = errors.New(".rec missing Build:")

func depRead(tgt *Tgt) (*DepInfo, error) {
	data, err := os.ReadFile(tgt.Dep())
	if err != nil {
		return nil, err
	}
	r := recfile.NewReader(bytes.NewReader(data))
	m, err := r.NextMap()
	if err != nil {
		return nil, err
	}
	depInfo := DepInfo{}
	b := m["Build"]
	if b == "" {
		return nil, missingBuild
	}
	depInfo.build = b
	for {
		m, err := r.NextMap()
		if err != nil {
			if errors.Is(err, io.EOF) {
				break
			}
			return nil, err
		}
		switch m["Type"] {
		case DepTypeAlways:
			depInfo.always = true
		case DepTypeIfcreate:
			dep := m["Target"]
			if dep == "" {
				return nil, ErrBadRecFormat
			}
			depInfo.ifcreates = append(depInfo.ifcreates,
				NewTgt(path.Join(tgt.h, dep)))
		case DepTypeIfchange:
			dep := m["Target"]
			if dep == "" {
				return nil, ErrBadRecFormat
			}
			inode, err := inodeFromRec(m)
			if err != nil {
				log.Print(err)
				return nil, ErrBadRecFormat
			}
			hsh := mustHexDecode(m["Hash"])
			depInfo.ifchanges = append(depInfo.ifchanges, DepInfoIfchange{
				tgt: NewTgt(path.Join(tgt.h, dep)), inode: inode, hash: hsh,
			})
		case DepTypeStamp:
			hsh := m["Hash"]
			if hsh == "" {
				return nil, ErrBadRecFormat
			}
			depInfo.stamp = mustHexDecode(hsh)
		default:
			return nil, ErrBadRecFormat
		}
	}
	return &depInfo, nil
}

func depReadOnlyIfchanges(pth string) (ifchanges []string, err error) {
	data, err := os.ReadFile(pth)
	if err != nil {
		return
	}
	r := recfile.NewReader(bytes.NewReader(data))
	var m map[string]string
	for {
		m, err = r.NextMap()
		if err != nil {
			if errors.Is(err, io.EOF) {
				err = nil
				break
			}
			return
		}
		if m["Type"] == DepTypeIfchange {
			ifchanges = append(ifchanges, m["Target"])
		}
	}
	return
}

func depReadBuild(pth string) (string, error) {
	fd, err := os.Open(pth)
	if err != nil {
		return "", err
	}
	r := recfile.NewReader(fd)
	m, err := r.NextMap()
	fd.Close()
	if err != nil {
		return "", err
	}
	build := m["Build"]
	if build == "" {
		err = missingBuild
	}
	return build, err
}