// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sfnt

import (
	"sort"
)

const (
	hexScriptLatn  = uint32(0x6c61746e) // latn
	hexScriptDFLT  = uint32(0x44464c54) // DFLT
	hexFeatureKern = uint32(0x6b65726e) // kern
)

//kernFunc returns the unscaled kerning value for kerning pair a+b.
// Returns ErrNotFound if no kerning is specified for this pair.
type kernFunc func(a, b GlyphIndex) (int16, error)

func (f *Font) parseGPOSKern(buf []byte) ([]byte, []kernFunc, error) {
	// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos

	if f.gpos.length == 0 {
		return buf, nil, nil
	}
	const headerSize = 10 // GPOS header v1.1 is 14 bytes, but we don't support FeatureVariations
	if f.gpos.length < headerSize {
		return buf, nil, errInvalidGPOSTable
	}

	buf, err := f.src.view(buf, int(f.gpos.offset), headerSize)
	if err != nil {
		return buf, nil, err
	}

	// check for version 1.0/1.1
	if u16(buf) != 1 || u16(buf[2:]) > 1 {
		return buf, nil, errUnsupportedGPOSTable
	}
	scriptListOffset := u16(buf[4:])
	featureListOffset := u16(buf[6:])
	lookupListOffset := u16(buf[8:])

	// get all feature indices for latn script
	buf, featureIdxs, err := f.parseGPOSScriptFeatures(buf, int(f.gpos.offset)+int(scriptListOffset), hexScriptLatn)
	if err != nil {
		return buf, nil, err
	}
	if len(featureIdxs) == 0 {
		// get all feature indices for DFLT script
		buf, featureIdxs, err = f.parseGPOSScriptFeatures(buf, int(f.gpos.offset)+int(scriptListOffset), hexScriptDFLT)
		if err != nil {
			return buf, nil, err
		}
		if len(featureIdxs) == 0 {
			return buf, nil, nil
		}
	}

	// get all lookup indices for kern features
	buf, lookupIdx, err := f.parseGPOSFeaturesLookup(buf, int(f.gpos.offset)+int(featureListOffset), featureIdxs, hexFeatureKern)

	// LookupTableList: lookupCount,[]lookups
	buf, numLookupTables, err := f.src.varLenView(buf, int(f.gpos.offset)+int(lookupListOffset), 2, 0, 2)
	if err != nil {
		return buf, nil, err
	}

	var kernFuncs []kernFunc

lookupTables:
	for _, n := range lookupIdx {
		if n > numLookupTables {
			return buf, nil, errInvalidGPOSTable
		}
		tableOffset := int(f.gpos.offset) + int(lookupListOffset) + int(u16(buf[2+n*2:]))

		// LookupTable: lookupType, lookupFlag, subTableCount, []subtableOffsets, markFilteringSet
		buf, numSubTables, err := f.src.varLenView(buf, tableOffset, 8, 4, 2)
		if err != nil {
			return buf, nil, err
		}

		flags := u16(buf[2:])

		subTableOffsets := make([]int, numSubTables)
		for i := 0; i < int(numSubTables); i++ {
			subTableOffsets[i] = int(tableOffset) + int(u16(buf[6+i*2:]))
		}

		switch lookupType := u16(buf); lookupType {
		case 2: // PairPos table
		case 9:
			// Extension Positioning table defines an additional u32 offset
			// to allow subtables to exceed the 16-bit limit.
			for i := range subTableOffsets {
				buf, err = f.src.view(buf, subTableOffsets[i], 8)
				if err != nil {
					return buf, nil, err
				}
				if format := u16(buf); format != 1 {
					return buf, nil, errUnsupportedExtensionPosFormat
				}
				if lookupType := u16(buf[2:]); lookupType != 2 {
					continue lookupTables
				}
				subTableOffsets[i] += int(u32(buf[4:]))
			}
		default: // other types are not supported
			continue
		}

		if flags&0x0010 > 0 {
			// useMarkFilteringSet enabled, skip as it is not supported
			continue
		}

		for _, subTableOffset := range subTableOffsets {
			buf, err = f.src.view(buf, int(subTableOffset), 4)
			if err != nil {
				return buf, nil, err
			}
			format := u16(buf)

			var lookupIndex indexLookupFunc
			buf, lookupIndex, err = f.makeCachedCoverageLookup(buf, subTableOffset+int(u16(buf[2:])))
			if err != nil {
				return buf, nil, err
			}

			switch format {
			case 1: // Adjustments for Glyph Pairs
				buf, kern, err := f.parsePairPosFormat1(buf, subTableOffset, lookupIndex)
				if err != nil {
					return buf, nil, err
				}
				if kern != nil {
					kernFuncs = append(kernFuncs, kern)
				}
			case 2: // Class Pair Adjustment
				buf, kern, err := f.parsePairPosFormat2(buf, subTableOffset, lookupIndex)
				if err != nil {
					return buf, nil, err
				}
				if kern != nil {
					kernFuncs = append(kernFuncs, kern)
				}
			}
		}
	}

	return buf, kernFuncs, nil
}

func (f *Font) parsePairPosFormat1(buf []byte, offset int, lookupIndex indexLookupFunc) ([]byte, kernFunc, error) {
	// PairPos Format 1: posFormat, coverageOffset, valueFormat1,
	// valueFormat2, pairSetCount, []pairSetOffsets
	var err error
	var nPairs int
	buf, nPairs, err = f.src.varLenView(buf, offset, 10, 8, 2)
	if err != nil {
		return buf, nil, err
	}
	// check valueFormat1 and valueFormat2 flags
	if u16(buf[4:]) != 0x04 || u16(buf[6:]) != 0x00 {
		// we only support kerning with X_ADVANCE for first glyph
		return buf, nil, nil
	}

	// PairPos table contains an array of offsets to PairSet
	// tables, which contains an array of PairValueRecords.
	// Calculate length of complete PairPos table by jumping to
	// last PairSet.
	// We need to iterate all offsets to find the last pair as
	// offsets are not sorted and can be repeated.
	var lastPairSetOffset int
	for n := 0; n < nPairs; n++ {
		pairOffset := int(u16(buf[10+n*2:]))
		if pairOffset > lastPairSetOffset {
			lastPairSetOffset = pairOffset
		}
	}
	buf, err = f.src.view(buf, offset+lastPairSetOffset, 2)
	if err != nil {
		return buf, nil, err
	}

	pairValueCount := int(u16(buf))
	// Each PairSet contains the secondGlyph (u16) and one or more value records (all u16).
	// We only support lookup tables with one value record (X_ADVANCE, see valueFormat1/2 above).
	lastPairSetLength := 2 + pairValueCount*4

	length := lastPairSetOffset + lastPairSetLength
	buf, err = f.src.view(buf, offset, length)
	if err != nil {
		return buf, nil, err
	}

	kern := makeCachedPairPosGlyph(lookupIndex, nPairs, buf)
	return buf, kern, nil
}

func (f *Font) parsePairPosFormat2(buf []byte, offset int, lookupIndex indexLookupFunc) ([]byte, kernFunc, error) {
	// PairPos Format 2:
	// posFormat, coverageOffset, valueFormat1, valueFormat2,
	// classDef1Offset, classDef2Offset, class1Count, class2Count,
	// []class1Records
	var err error
	buf, err = f.src.view(buf, offset, 16)
	if err != nil {
		return buf, nil, err
	}
	// check valueFormat1 and valueFormat2 flags
	if u16(buf[4:]) != 0x04 || u16(buf[6:]) != 0x00 {
		// we only support kerning with X_ADVANCE for first glyph
		return buf, nil, nil
	}
	numClass1 := int(u16(buf[12:]))
	numClass2 := int(u16(buf[14:]))
	cdef1Offset := offset + int(u16(buf[8:]))
	cdef2Offset := offset + int(u16(buf[10:]))
	var cdef1, cdef2 classLookupFunc
	buf, cdef1, err = f.makeCachedClassLookup(buf, cdef1Offset)
	if err != nil {
		return buf, nil, err
	}
	buf, cdef2, err = f.makeCachedClassLookup(buf, cdef2Offset)
	if err != nil {
		return buf, nil, err
	}

	buf, err = f.src.view(buf, offset+16, numClass1*numClass2*2)
	if err != nil {
		return buf, nil, err
	}
	kern := makeCachedPairPosClass(
		lookupIndex,
		numClass1,
		numClass2,
		cdef1,
		cdef2,
		buf,
	)

	return buf, kern, nil
}

// parseGPOSScriptFeatures returns all indices of features in FeatureTable that
// are valid for the given script.
// Returns features from DefaultLangSys, different languages are not supported.
// However, all observed fonts either do not use different languages or use the
// same features as DefaultLangSys.
func (f *Font) parseGPOSScriptFeatures(buf []byte, offset int, script uint32) ([]byte, []int, error) {
	// ScriptList table: scriptCount, []scriptRecords{scriptTag, scriptOffset}
	buf, numScriptTables, err := f.src.varLenView(buf, offset, 2, 0, 6)
	if err != nil {
		return buf, nil, err
	}

	// Search ScriptTables for script
	var scriptTableOffset uint16
	for i := 0; i < numScriptTables; i++ {
		scriptTag := u32(buf[2+i*6:])
		if scriptTag == script {
			scriptTableOffset = u16(buf[2+i*6+4:])
			break
		}
	}
	if scriptTableOffset == 0 {
		return buf, nil, nil
	}

	// Script table: defaultLangSys, langSysCount, []langSysRecords{langSysTag, langSysOffset}
	buf, err = f.src.view(buf, offset+int(scriptTableOffset), 2)
	if err != nil {
		return buf, nil, err
	}
	defaultLangSysOffset := u16(buf)

	if defaultLangSysOffset == 0 {
		return buf, nil, nil
	}

	// LangSys table: lookupOrder (reserved), requiredFeatureIndex, featureIndexCount, []featureIndices
	buf, numFeatures, err := f.src.varLenView(buf, offset+int(scriptTableOffset)+int(defaultLangSysOffset), 6, 4, 2)

	featureIdxs := make([]int, numFeatures)
	for i := range featureIdxs {
		featureIdxs[i] = int(u16(buf[6+i*2:]))
	}
	return buf, featureIdxs, nil
}

func (f *Font) parseGPOSFeaturesLookup(buf []byte, offset int, featureIdxs []int, feature uint32) ([]byte, []int, error) {
	// FeatureList table: featureCount, []featureRecords{featureTag, featureOffset}
	buf, numFeatureTables, err := f.src.varLenView(buf, offset, 2, 0, 6)
	if err != nil {
		return buf, nil, err
	}

	lookupIdx := make([]int, 0, 4)

	for _, fidx := range featureIdxs {
		if fidx > numFeatureTables {
			return buf, nil, errInvalidGPOSTable
		}
		featureTag := u32(buf[2+fidx*6:])
		if featureTag != feature {
			continue
		}
		featureOffset := u16(buf[2+fidx*6+4:])

		buf, numLookups, err := f.src.varLenView(nil, offset+int(featureOffset), 4, 2, 2)
		if err != nil {
			return buf, nil, err
		}

		for i := 0; i < numLookups; i++ {
			lookupIdx = append(lookupIdx, int(u16(buf[4+i*2:])))
		}
	}

	return buf, lookupIdx, nil
}

func makeCachedPairPosGlyph(cov indexLookupFunc, num int, buf []byte) kernFunc {
	glyphs := make([]byte, len(buf))
	copy(glyphs, buf)
	return func(a, b GlyphIndex) (int16, error) {
		idx, found := cov(a)
		if !found {
			return 0, ErrNotFound
		}
		if idx >= num {
			return 0, ErrNotFound
		}
		offset := int(u16(glyphs[10+idx*2:]))
		if offset+1 >= len(glyphs) {
			return 0, errInvalidGPOSTable
		}

		count := int(u16(glyphs[offset:]))
		for i := 0; i < count; i++ {
			secondGlyphIndex := GlyphIndex(int(u16(glyphs[offset+2+i*4:])))
			if secondGlyphIndex == b {
				return int16(u16(glyphs[offset+2+i*4+2:])), nil
			}
			if secondGlyphIndex > b {
				return 0, ErrNotFound
			}
		}

		return 0, ErrNotFound
	}
}

func makeCachedPairPosClass(cov indexLookupFunc, num1, num2 int, cdef1, cdef2 classLookupFunc, buf []byte) kernFunc {
	glyphs := make([]byte, len(buf))
	copy(glyphs, buf)
	return func(a, b GlyphIndex) (int16, error) {
		// check coverage to avoid selection of default class 0
		_, found := cov(a)
		if !found {
			return 0, ErrNotFound
		}
		idxa := cdef1(a)
		idxb := cdef2(b)
		return int16(u16(glyphs[(idxb+idxa*num2)*2:])), nil
	}
}

// indexLookupFunc returns the index into a PairPos table for the provided glyph.
// Returns false if the glyph is not covered by this lookup.
type indexLookupFunc func(GlyphIndex) (int, bool)

func (f *Font) makeCachedCoverageLookup(buf []byte, offset int) ([]byte, indexLookupFunc, error) {
	var err error
	buf, err = f.src.view(buf, offset, 2)
	if err != nil {
		return buf, nil, err
	}
	switch u16(buf) {
	case 1:
		// Coverage Format 1: coverageFormat, glyphCount, []glyphArray
		buf, _, err = f.src.varLenView(buf, offset, 4, 2, 2)
		if err != nil {
			return buf, nil, err
		}
		return buf, makeCachedCoverageList(buf[2:]), nil
	case 2:
		// Coverage Format 2: coverageFormat, rangeCount, []rangeRecords{startGlyphID, endGlyphID, startCoverageIndex}
		buf, _, err = f.src.varLenView(buf, offset, 4, 2, 6)
		if err != nil {
			return buf, nil, err
		}
		return buf, makeCachedCoverageRange(buf[2:]), nil
	default:
		return buf, nil, errUnsupportedCoverageFormat
	}
}

func makeCachedCoverageList(buf []byte) indexLookupFunc {
	num := int(u16(buf))
	list := make([]byte, len(buf)-2)
	copy(list, buf[2:])
	return func(gi GlyphIndex) (int, bool) {
		idx := sort.Search(num, func(i int) bool {
			return gi <= GlyphIndex(u16(list[i*2:]))
		})
		if idx < num && GlyphIndex(u16(list[idx*2:])) == gi {
			return idx, true
		}

		return 0, false
	}
}

func makeCachedCoverageRange(buf []byte) indexLookupFunc {
	num := int(u16(buf))
	ranges := make([]byte, len(buf)-2)
	copy(ranges, buf[2:])
	return func(gi GlyphIndex) (int, bool) {
		if num == 0 {
			return 0, false
		}

		// ranges is an array of startGlyphID, endGlyphID and startCoverageIndex
		// Ranges are non-overlapping.
		// The following GlyphIDs/index pairs are stored as follows:
		//	 pairs: 130=0, 131=1, 132=2, 133=3, 134=4, 135=5, 137=6
		//   ranges: 130, 135, 0    137, 137, 6
		// startCoverageIndex is used to calculate the index without counting
		// the length of the preceeding ranges

		idx := sort.Search(num, func(i int) bool {
			return gi <= GlyphIndex(u16(ranges[i*6:]))
		})
		// idx either points to a matching start, or to the next range (or idx==num)
		// e.g. with the range example from above: 130 points to 130-135 range, 133 points to 137-137 range

		// check if gi is the start of a range, but only if sort.Search returned a valid result
		if idx < num {
			if start := u16(ranges[idx*6:]); gi == GlyphIndex(start) {
				return int(u16(ranges[idx*6+4:])), true
			}
		}
		// check if gi is in previous range
		if idx > 0 {
			idx--
			start, end := u16(ranges[idx*6:]), u16(ranges[idx*6+2:])
			if gi >= GlyphIndex(start) && gi <= GlyphIndex(end) {
				return int(u16(ranges[idx*6+4:]) + uint16(gi) - start), true
			}
		}

		return 0, false
	}
}

// classLookupFunc returns the class ID for the provided glyph. Returns 0
// (default class) for glyphs not covered by this lookup.
type classLookupFunc func(GlyphIndex) int

func (f *Font) makeCachedClassLookup(buf []byte, offset int) ([]byte, classLookupFunc, error) {
	var err error
	buf, err = f.src.view(buf, offset, 2)
	if err != nil {
		return buf, nil, err
	}
	switch u16(buf) {
	case 1:
		// ClassDefFormat 1: classFormat, startGlyphID, glyphCount, []classValueArray
		buf, _, err = f.src.varLenView(buf, offset, 6, 4, 2)
		if err != nil {
			return buf, nil, err
		}
		return buf, makeCachedClassLookupFormat1(buf), nil
	case 2:
		// ClassDefFormat 2: classFormat, classRangeCount, []classRangeRecords
		buf, _, err = f.src.varLenView(buf, offset, 4, 2, 6)
		if err != nil {
			return buf, nil, err
		}
		return buf, makeCachedClassLookupFormat2(buf), nil
	default:
		return buf, nil, errUnsupportedClassDefFormat
	}
}

func makeCachedClassLookupFormat1(buf []byte) classLookupFunc {
	startGI := u16(buf[2:])
	num := u16(buf[4:])
	classIDs := make([]byte, len(buf)-4)
	copy(classIDs, buf[6:])

	return func(gi GlyphIndex) int {
		// classIDs is an array of target class IDs. gi is the index into that array (minus startGI).
		if gi < GlyphIndex(startGI) || gi >= GlyphIndex(startGI+num) {
			// default to class 0
			return 0
		}
		return int(u16(classIDs[(int(gi)-int(startGI))*2:]))
	}
}

func makeCachedClassLookupFormat2(buf []byte) classLookupFunc {
	num := int(u16(buf[2:]))
	classRanges := make([]byte, len(buf)-2)
	copy(classRanges, buf[4:])

	return func(gi GlyphIndex) int {
		if num == 0 {
			return 0 // default to class 0
		}

		// classRange is an array of startGlyphID, endGlyphID and target class ID.
		// Ranges are non-overlapping.
		// E.g. 130, 135, 1   137, 137, 5   etc

		idx := sort.Search(num, func(i int) bool {
			return gi <= GlyphIndex(u16(classRanges[i*6:]))
		})
		// idx either points to a matching start, or to the next range (or idx==num)
		// e.g. with the range example from above: 130 points to 130-135 range, 133 points to 137-137 range

		// check if gi is the start of a range, but only if sort.Search returned a valid result
		if idx < num {
			if start := u16(classRanges[idx*6:]); gi == GlyphIndex(start) {
				return int(u16(classRanges[idx*6+4:]))
			}
		}
		// check if gi is in previous range
		if idx > 0 {
			idx--
			start, end := u16(classRanges[idx*6:]), u16(classRanges[idx*6+2:])
			if gi >= GlyphIndex(start) && gi <= GlyphIndex(end) {
				return int(u16(classRanges[idx*6+4:]))
			}
		}
		// default to class 0
		return 0
	}
}