package transform

import (
	"bytes"
	bp "github.com/spf13/hugo/bufferpool"
	"net/url"
	"strings"
	"unicode/utf8"
)

type matchState int

const (
	matchStateNone matchState = iota
	matchStateWhitespace
	matchStatePartial
	matchStateFull
)

const (
	matchPrefixSrc int = iota
	matchPrefixHref
)

type contentlexer struct {
	content []byte

	pos   int // input position
	start int // item start position
	width int // width of last element

	matchers     []absURLMatcher
	state        stateFunc
	prefixLookup *prefixes

	b *bytes.Buffer
}

type stateFunc func(*contentlexer) stateFunc

type prefixRunes []rune

type prefixes struct {
	pr   []prefixRunes
	curr prefixRunes // current prefix lookup table
	i    int         // current index

	// first rune in potential match
	first rune

	// match-state:
	// none, whitespace, partial, full
	ms matchState
}

// match returns partial and full match for the prefix in play
// - it's a full match if all prefix runes has checked out in row
// - it's a partial match if it's on its way towards a full match
func (l *contentlexer) match(r rune) {
	p := l.prefixLookup
	if p.curr == nil {
		// assumes prefixes all start off on a different rune
		// works in this special case: href, src
		p.i = 0
		for _, pr := range p.pr {
			if pr[p.i] == r {
				fullMatch := len(p.pr) == 1
				p.first = r
				if !fullMatch {
					p.curr = pr
					l.prefixLookup.ms = matchStatePartial
				} else {
					l.prefixLookup.ms = matchStateFull
				}
				return
			}
		}
	} else {
		p.i++
		if p.curr[p.i] == r {
			fullMatch := len(p.curr) == p.i+1
			if fullMatch {
				p.curr = nil
				l.prefixLookup.ms = matchStateFull
			} else {
				l.prefixLookup.ms = matchStatePartial
			}
			return
		}

		p.curr = nil
	}

	l.prefixLookup.ms = matchStateNone
}

func (l *contentlexer) emit() {
	l.b.Write(l.content[l.start:l.pos])
	l.start = l.pos
}

var mainPrefixRunes = []prefixRunes{{'s', 'r', 'c', '='}, {'h', 'r', 'e', 'f', '='}}

type absURLMatcher struct {
	prefix      int
	match       []byte
	replacement []byte
}

func (a absURLMatcher) isSourceType() bool {
	return a.prefix == matchPrefixSrc
}

func checkCandidate(l *contentlexer) {
	isSource := l.prefixLookup.first == 's'
	for _, m := range l.matchers {

		if isSource && !m.isSourceType() || !isSource && m.isSourceType() {
			continue
		}

		if bytes.HasPrefix(l.content[l.pos:], m.match) {
			// check for schemaless urls
			posAfter := l.pos + len(m.match)
			if int(posAfter) >= len(l.content) {
				return
			}
			r, _ := utf8.DecodeRune(l.content[posAfter:])
			if r == '/' {
				// schemaless: skip
				return
			}
			if l.pos > l.start {
				l.emit()
			}
			l.pos += len(m.match)
			l.b.Write(m.replacement)
			l.start = l.pos
			return

		}
	}
}

func (l *contentlexer) replace() {
	contentLength := len(l.content)
	var r rune

	for {
		if int(l.pos) >= contentLength {
			l.width = 0
			break
		}

		var width int = 1
		r = rune(l.content[l.pos])
		if r >= utf8.RuneSelf {
			r, width = utf8.DecodeRune(l.content[l.pos:])
		}
		l.width = width
		l.pos += l.width

		if r == ' ' {
			l.prefixLookup.ms = matchStateWhitespace
		} else if l.prefixLookup.ms != matchStateNone {
			l.match(r)
			if l.prefixLookup.ms == matchStateFull {
				checkCandidate(l)
			}
		}

	}

	// Done!
	if l.pos > l.start {
		l.emit()
	}
}

func doReplace(content []byte, matchers []absURLMatcher) []byte {
	b := bp.GetBuffer()
	defer bp.PutBuffer(b)

	lexer := &contentlexer{content: content,
		b:            b,
		prefixLookup: &prefixes{pr: mainPrefixRunes},
		matchers:     matchers}

	lexer.replace()

	return b.Bytes()
}

type absURLReplacer struct {
	htmlMatchers []absURLMatcher
	xmlMatchers  []absURLMatcher
}

func newAbsurlReplacer(baseURL string) *absURLReplacer {
	u, _ := url.Parse(baseURL)
	base := strings.TrimRight(u.String(), "/")

	// HTML
	dqHTMLMatch := []byte("\"/")
	sqHTMLMatch := []byte("'/")

	// XML
	dqXMLMatch := []byte(""/")
	sqXMLMatch := []byte("'/")

	dqHTML := []byte("\"" + base + "/")
	sqHTML := []byte("'" + base + "/")

	dqXML := []byte(""" + base + "/")
	sqXML := []byte("'" + base + "/")

	return &absURLReplacer{
		htmlMatchers: []absURLMatcher{
			{matchPrefixSrc, dqHTMLMatch, dqHTML},
			{matchPrefixSrc, sqHTMLMatch, sqHTML},
			{matchPrefixHref, dqHTMLMatch, dqHTML},
			{matchPrefixHref, sqHTMLMatch, sqHTML}},
		xmlMatchers: []absURLMatcher{
			{matchPrefixSrc, dqXMLMatch, dqXML},
			{matchPrefixSrc, sqXMLMatch, sqXML},
			{matchPrefixHref, dqXMLMatch, dqXML},
			{matchPrefixHref, sqXMLMatch, sqXML},
		}}

}

func (au *absURLReplacer) replaceInHTML(content []byte) []byte {
	return doReplace(content, au.htmlMatchers)
}

func (au *absURLReplacer) replaceInXML(content []byte) []byte {
	return doReplace(content, au.xmlMatchers)
}