package canoninja

import (
	"bytes"
	"crypto/sha1"
	"encoding/hex"
	"fmt"
	"io"
)

var (
	rulePrefix  = []byte("rule ")
	buildPrefix = []byte("build ")
	phonyRule   = []byte("phony")
)

func Generate(path string, buffer []byte, sink io.Writer) error {
	// Break file into lines
	from := 0
	var lines [][]byte
	for from < len(buffer) {
		line := getLine(buffer[from:])
		lines = append(lines, line)
		from += len(line)
	}

	// FOr each rule, calculate and remember its digest
	ruleDigest := make(map[string]string)
	for i := 0; i < len(lines); {
		if bytes.HasPrefix(lines[i], rulePrefix) {
			// Find ruleName
			rn := ruleName(lines[i])
			if len(rn) == 0 {
				return fmt.Errorf("%s:%d: rule name is missing or on the next line", path, i+1)
			}
			sRuleName := string(rn)
			if _, ok := ruleDigest[sRuleName]; ok {
				return fmt.Errorf("%s:%d: the rule %s has been already defined", path, i+1, sRuleName)
			}
			// Calculate rule text digest as a digests of line digests.
			var digests []byte
			doDigest := func(b []byte) {
				h := sha1.New()
				h.Write(b)
				digests = h.Sum(digests)

			}
			// For the first line, digest everything after rule's name
			doDigest(lines[i][cap(lines[i])+len(rn)-cap(rn):])
			for i++; i < len(lines) && lines[i][0] == ' '; i++ {
				doDigest(lines[i])
			}
			h := sha1.New()
			h.Write(digests)
			ruleDigest[sRuleName] = "R" + hex.EncodeToString(h.Sum(nil))

		} else {
			i++
		}
	}

	// Rewrite rule names.
	for i, line := range lines {
		if bytes.HasPrefix(line, buildPrefix) {
			brn := getBuildRuleName(line)
			if bytes.Equal(brn, phonyRule) {
				sink.Write(line)
				continue
			}
			if len(brn) == 0 {
				return fmt.Errorf("%s:%d: build statement lacks rule name", path, i+1)
			}
			sink.Write(line[0 : cap(line)-cap(brn)])
			if digest, ok := ruleDigest[string(brn)]; ok {
				sink.Write([]byte(digest))
			} else {
				return fmt.Errorf("%s:%d: no rule for this build target", path, i+1)
			}
			sink.Write(line[cap(line)+len(brn)-cap(brn):])
		} else if bytes.HasPrefix(line, rulePrefix) {
			rn := ruleName(line)
			// Write everything before it
			sink.Write(line[0 : cap(line)-cap(rn)])
			sink.Write([]byte(ruleDigest[string(rn)]))
			sink.Write(line[cap(line)+len(rn)-cap(rn):])
		} else {
			//goland:noinspection GoUnhandledErrorResult
			sink.Write(line)
		}
	}
	return nil
}

func getLine(b []byte) []byte {
	if n := bytes.IndexByte(b, '\n'); n >= 0 {
		return b[:n+1]
	}
	return b
}

// Returns build statement's rule name
func getBuildRuleName(line []byte) []byte {
	n := bytes.IndexByte(line, ':')
	if n <= 0 {
		return nil
	}
	ruleName := line[n+1:]
	if ruleName[0] == ' ' {
		ruleName = bytes.TrimLeft(ruleName, " ")
	}
	if n := bytes.IndexAny(ruleName, " \t\r\n"); n >= 0 {
		ruleName = ruleName[0:n]
	}
	return ruleName
}

// Returns rule statement's rule name
func ruleName(lineAfterRule []byte) []byte {
	ruleName := lineAfterRule[len(rulePrefix):]
	if len(ruleName) == 0 {
		return ruleName
	}
	if ruleName[0] == ' ' {
		ruleName = bytes.TrimLeft(ruleName, " ")
	}
	if n := bytes.IndexAny(ruleName, " \t\r\n"); n >= 0 {
		ruleName = ruleName[0:n]
	}
	return ruleName
}