// Copyright 2015 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 runes

import (

	"unicode/utf8"

	"golang.org/x/text/transform"

)

// Note: below we pass invalid UTF-8 to the tIn and tNotIn transformers as is.

// This is done for various reasons:

// - To retain the semantics of the Nop transformer: if input is passed to a Nop

//   one would expect it to be unchanged.

// - It would be very expensive to pass a converted RuneError to a transformer:

//   a transformer might need more source bytes after RuneError, meaning that

//   the only way to pass it safely is to create a new buffer and manage the

//   intermingling of RuneErrors and normal input.

// - Many transformers leave ill-formed UTF-8 as is, so this is not

//   inconsistent. Generally ill-formed UTF-8 is only replaced if it is a

//   logical consequence of the operation (as for Map) or if it otherwise would

//   pose security concerns (as for Remove).

// - An alternative would be to return an error on ill-formed UTF-8, but this

//   would be inconsistent with other operations.

// If returns a transformer that applies tIn to consecutive runes for which

// s.Contains(r) and tNotIn to consecutive runes for which !s.Contains(r). Reset

// is called on tIn and tNotIn at the start of each run. A Nop transformer will

// substitute a nil value passed to tIn or tNotIn. Invalid UTF-8 is translated

// to RuneError to determine which transformer to apply, but is passed as is to

// the respective transformer.

func If(s Set, tIn, tNotIn transform.Transformer) Transformer {

	if tIn == nil && tNotIn == nil {

		return Transformer{transform.Nop}

	}

	if tIn == nil {

		tIn = transform.Nop

	}

	if tNotIn == nil {

		tNotIn = transform.Nop

	}

	sIn, ok := tIn.(transform.SpanningTransformer)

	if !ok {

		sIn = dummySpan{tIn}

	}

	sNotIn, ok := tNotIn.(transform.SpanningTransformer)

	if !ok {

		sNotIn = dummySpan{tNotIn}

	}

	a := &cond{

		tIn:    sIn,

		tNotIn: sNotIn,

		f:      s.Contains,

	}

	a.Reset()

	return Transformer{a}

}

type dummySpan struct{ transform.Transformer }

func (d dummySpan) Span(src []byte, atEOF bool) (n int, err error) {

	return 0, transform.ErrEndOfSpan

}

type cond struct {

	tIn, tNotIn transform.SpanningTransformer

	f           func(rune) bool

	check       func(rune) bool               // current check to perform

	t           transform.SpanningTransformer // current transformer to use

}

// Reset implements transform.Transformer.

func (t *cond) Reset() {

	t.check = t.is

	t.t = t.tIn

	t.t.Reset() // notIn will be reset on first usage.

}

func (t *cond) is(r rune) bool {

	if t.f(r) {

		return true

	}

	t.check = t.isNot

	t.t = t.tNotIn

	t.tNotIn.Reset()

	return false

}

func (t *cond) isNot(r rune) bool {

	if !t.f(r) {

		return true

	}

	t.check = t.is

	t.t = t.tIn

	t.tIn.Reset()

	return false

}

// This implementation of Span doesn't help all too much, but it needs to be

// there to satisfy this package's Transformer interface.

// TODO: there are certainly room for improvements, though. For example, if

// t.t == transform.Nop (which will a common occurrence) it will save a bundle

// to special-case that loop.

func (t *cond) Span(src []byte, atEOF bool) (n int, err error) {

	p := 0

	for n < len(src) && err == nil {

		// Don't process too much at a time as the Spanner that will be

		// called on this block may terminate early.

		const maxChunk = 4096

		max := len(src)

		if v := n + maxChunk; v < max {

			max = v

		}

		atEnd := false

		size := 0

		current := t.t

		for ; p < max; p += size {

			r := rune(src[p])

			if r < utf8.RuneSelf {

				size = 1

			} else if r, size = utf8.DecodeRune(src[p:]); size == 1 {

				if !atEOF && !utf8.FullRune(src[p:]) {

					err = transform.ErrShortSrc

					break

				}

			}

			if !t.check(r) {

				// The next rune will be the start of a new run.

				atEnd = true

				break

			}

		}

		n2, err2 := current.Span(src[n:p], atEnd || (atEOF && p == len(src)))

		n += n2

		if err2 != nil {

			return n, err2

		}

		// At this point either err != nil or t.check will pass for the rune at p.

		p = n + size

	}

	return n, err

}

func (t *cond) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {

	p := 0

	for nSrc < len(src) && err == nil {

		// Don't process too much at a time, as the work might be wasted if the

		// destination buffer isn't large enough to hold the result or a

		// transform returns an error early.

		const maxChunk = 4096

		max := len(src)

		if n := nSrc + maxChunk; n < len(src) {

			max = n

		}

		atEnd := false

		size := 0

		current := t.t

		for ; p < max; p += size {

			r := rune(src[p])

			if r < utf8.RuneSelf {

				size = 1

			} else if r, size = utf8.DecodeRune(src[p:]); size == 1 {

				if !atEOF && !utf8.FullRune(src[p:]) {

					err = transform.ErrShortSrc

					break

				}

			}

			if !t.check(r) {

				// The next rune will be the start of a new run.

				atEnd = true

				break

			}

		}

		nDst2, nSrc2, err2 := current.Transform(dst[nDst:], src[nSrc:p], atEnd || (atEOF && p == len(src)))

		nDst += nDst2

		nSrc += nSrc2

		if err2 != nil {

			return nDst, nSrc, err2

		}

		// At this point either err != nil or t.check will pass for the rune at p.

		p = nSrc + size

	}

	return nDst, nSrc, err

}