// Copyright (C) 2016 Mikael Berthe <mikael@lilotux.net>. All rights reserved.
// Use of this source code is governed by the MIT license,
// which can be found in the LICENSE file.

package takuzu

// This file contains the takuzu validation functions and methods.

// checkRange returns true if the range is completely defined, and an error
// if it doesn't follow the rules for a takuzu line or column
// Note that the boolean might be invalid if the error is not nil.
func checkRange(cells []Cell) (bool, error) {
	full := true
	size := len(cells)
	counters := []int{0, 0}

	var prevCell Cell
	var prevCellCount int

	for _, c := range cells {
		if !c.Defined {
			full = false
			prevCell.Defined = false
			prevCellCount = 0
			continue
		}
		counters[c.Value]++
		if prevCellCount == 0 {
			prevCellCount = 1
		} else {
			if c.Value == prevCell.Value {
				prevCellCount++
				if prevCellCount > 2 {
					v := c.Value
					return full, validationError{
						ErrorType: ErrorTooManyAdjacentValues,
						CellValue: &v,
					}
				}
			} else {
				prevCellCount = 1
			}

		}
		prevCell = c
	}
	if counters[0] > size/2 {
		v := 0
		return full, validationError{
			ErrorType: ErrorTooManyValues,
			CellValue: &v,
		}
	}
	if counters[1] > size/2 {
		v := 1
		return full, validationError{
			ErrorType: ErrorTooManyValues,
			CellValue: &v,
		}
	}
	return full, nil
}

// CheckRangeCounts returns true if all cells of the provided range are defined,
// as well as the number of 0s and the number of 1s in the range.
func CheckRangeCounts(cells []Cell) (full bool, n0, n1 int) {
	counters := []int{0, 0}
	full = true

	for _, c := range cells {
		if c.Defined {
			counters[c.Value]++
		} else {
			full = false
		}
	}
	return full, counters[0], counters[1]
}

// CheckLine returns an error if the line i fails validation
func (b Takuzu) CheckLine(i int) error {
	_, err := checkRange(b.GetLine(i))
	return err
}

// CheckColumn returns an error if the column i fails validation
func (b Takuzu) CheckColumn(i int) error {
	_, err := checkRange(b.GetColumn(i))
	return err
}

// Validate checks a whole board for errors (not completeness)
// Returns true if all cells are defined.
func (b Takuzu) Validate() (bool, error) {
	finished := true

	computeVal := func(cells []Cell) (val int) {
		for i := 0; i < len(cells); i++ {
			val += cells[i].Value * 1 << uint(i)
		}
		return
	}

	lineVals := make(map[int]bool)
	colVals := make(map[int]bool)

	for i := 0; i < b.Size; i++ {
		var d []Cell
		var full bool
		var err error

		// Let's check line i
		d = b.GetLine(i)
		full, err = checkRange(d)
		if err != nil {
			err := err.(validationError)
			err.LineNumber = &i
			return false, err
		}
		if full {
			hv := computeVal(d)
			if lineVals[hv] {
				err := validationError{
					ErrorType:  ErrorDuplicate,
					LineNumber: &i,
				}
				return false, err
			}
			lineVals[hv] = true
		} else {
			finished = false
		}

		// Let's check column i
		d = b.GetColumn(i)
		full, err = checkRange(d)
		if err != nil {
			err := err.(validationError)
			err.ColumnNumber = &i
			return false, err
		}
		if full {
			hv := computeVal(d)
			if colVals[hv] {
				err := validationError{
					ErrorType:    ErrorDuplicate,
					ColumnNumber: &i,
				}
				return false, err
			}
			colVals[hv] = true
		} else {
			finished = false
		}
	}
	return finished, nil
}