// Copyright 2017 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package parser

import (
 "fmt"
 "strings"
 "unicode"
 "unicode/utf8"
)

// A MakeString is a string that may contain variable substitutions in it.
// It can be considered as an alternating list of raw Strings and variable
// substitutions, where the first and last entries in the list must be raw
// Strings (possibly empty). The entirety of the text before the first variable,
// between two variables, and after the last variable will be considered a
// single String value. A MakeString that starts with a variable will have an
// empty first raw string, and a MakeString that ends with a  variable will have
// an empty last raw string.  Two sequential Variables will have an empty raw
// string between them.
//
// The MakeString is stored as two lists, a list of raw Strings and a list
// of Variables.  The raw string list is always one longer than the variable
// list.
//
// For example, "$(FOO)/bar/baz" will be represented as the
// following lists:
//
// {
//   Strings: ["", "/bar/baz"],
//   Variables: ["FOO"]
// }
type MakeString struct {
 StringPos Pos
 Strings   []string
 Variables []Variable
}

func SimpleMakeString(s string, pos Pos) *MakeString {
 return &MakeString{
  StringPos: pos,
  Strings:   []string{s},
 }
}

func (ms *MakeString) Clone() (result *MakeString) {
 clone := *ms
 return &clone
}

func (ms *MakeString) Pos() Pos {
 return ms.StringPos
}

func (ms *MakeString) End() Pos {
 pos := ms.StringPos
 if len(ms.Strings) > 1 {
  pos = ms.Variables[len(ms.Variables)-1].End()
 }
 return Pos(int(pos) + len(ms.Strings[len(ms.Strings)-1]))
}

func (ms *MakeString) appendString(s string) {
 if len(ms.Strings) == 0 {
  ms.Strings = []string{s}
  return
 } else {
  ms.Strings[len(ms.Strings)-1] += s
 }
}

func (ms *MakeString) appendVariable(v Variable) {
 if len(ms.Strings) == 0 {
  ms.Strings = []string{"", ""}
  ms.Variables = []Variable{v}
 } else {
  ms.Strings = append(ms.Strings, "")
  ms.Variables = append(ms.Variables, v)
 }
}

func (ms *MakeString) appendMakeString(other *MakeString) {
 last := len(ms.Strings) - 1
 ms.Strings[last] += other.Strings[0]
 ms.Strings = append(ms.Strings, other.Strings[1:]...)
 ms.Variables = append(ms.Variables, other.Variables...)
}

func (ms *MakeString) Value(scope Scope) string {
 if len(ms.Strings) == 0 {
  return ""
 } else {
  ret := unescape(ms.Strings[0])
  for i := range ms.Strings[1:] {
   ret += ms.Variables[i].Value(scope)
   ret += unescape(ms.Strings[i+1])
  }
  return ret
 }
}

func (ms *MakeString) Dump() string {
 if len(ms.Strings) == 0 {
  return ""
 } else {
  ret := ms.Strings[0]
  for i := range ms.Strings[1:] {
   ret += ms.Variables[i].Dump()
   ret += ms.Strings[i+1]
  }
  return ret
 }
}

func (ms *MakeString) Const() bool {
 return len(ms.Strings) <= 1
}

func (ms *MakeString) Empty() bool {
 return len(ms.Strings) == 0 || (len(ms.Strings) == 1 && ms.Strings[0] == "")
}

func (ms *MakeString) Split(sep string) []*MakeString {
 return ms.SplitN(sep, -1)
}

func (ms *MakeString) SplitN(sep string, n int) []*MakeString {
 return ms.splitNFunc(n, func(s string, n int) []string {
  return splitAnyN(s, sep, n)
 })
}

// Words splits MakeString into multiple makeStrings separated by whitespace.
// Thus, " a $(X)b  c " will be split into ["a", "$(X)b", "c"].
// Splitting a MakeString consisting solely of whitespace yields empty array.
func (ms *MakeString) Words() []*MakeString {
 var ch rune    // current character
 const EOF = -1 // no more characters
 const EOS = -2 // at the end of a string chunk

 // Next character's chunk and position
 iString := 0
 iChar := 0

 var words []*MakeString
 word := SimpleMakeString("", ms.Pos())

 nextChar := func() {
  if iString >= len(ms.Strings) {
   ch = EOF
  } else if iChar >= len(ms.Strings[iString]) {
   iString++
   iChar = 0
   ch = EOS
  } else {
   var w int
   ch, w = utf8.DecodeRuneInString(ms.Strings[iString][iChar:])
   iChar += w
  }
 }

 appendVariableAndAdvance := func() {
  if iString-1 < len(ms.Variables) {
   word.appendVariable(ms.Variables[iString-1])
  }
  nextChar()
 }

 appendCharAndAdvance := func(c rune) {
  if c != EOF {
   word.appendString(string(c))
  }
  nextChar()
 }

 nextChar()
 for ch != EOF {
  // Skip whitespace
  for ch == ' ' || ch == '\t' {
   nextChar()
  }
  if ch == EOS {
   // "... $(X)... " case. The current word should be empty.
   if !word.Empty() {
    panic(fmt.Errorf("%q: EOS while current word %q is not empty, iString=%d",
     ms.Dump(), word.Dump(), iString))
   }
   appendVariableAndAdvance()
  }
  // Copy word
  for ch != EOF {
   if ch == ' ' || ch == '\t' {
    words = append(words, word)
    word = SimpleMakeString("", ms.Pos())
    break
   }
   if ch == EOS {
    // "...a$(X)..." case. Append variable to the current word
    appendVariableAndAdvance()
   } else {
    if ch == '\\' {
     appendCharAndAdvance('\\')
    }
    appendCharAndAdvance(ch)
   }
  }
 }
 if !word.Empty() {
  words = append(words, word)
 }
 return words
}

func (ms *MakeString) splitNFunc(n int, splitFunc func(s string, n int) []string) []*MakeString {
 ret := []*MakeString{}

 curMs := SimpleMakeString("", ms.Pos())

 var i int
 var s string
 for i, s = range ms.Strings {
  if n != 0 {
   split := splitFunc(s, n)
   if n != -1 {
    if len(split) > n || len(split) == 0 {
     panic("oops!")
    } else {
     n -= len(split) - 1
    }
   }
   curMs.appendString(split[0])

   for _, r := range split[1:] {
    ret = append(ret, curMs)
    curMs = SimpleMakeString(r, ms.Pos())
   }
  } else {
   curMs.appendString(s)
  }

  if i < len(ms.Strings)-1 {
   curMs.appendVariable(ms.Variables[i])
  }
 }

 ret = append(ret, curMs)
 return ret
}

func (ms *MakeString) TrimLeftSpaces() {
 l := len(ms.Strings[0])
 ms.Strings[0] = strings.TrimLeftFunc(ms.Strings[0], unicode.IsSpace)
 ms.StringPos += Pos(len(ms.Strings[0]) - l)
}

func (ms *MakeString) TrimRightSpaces() {
 last := len(ms.Strings) - 1
 ms.Strings[last] = strings.TrimRightFunc(ms.Strings[last], unicode.IsSpace)
}

func (ms *MakeString) TrimRightOne() {
 last := len(ms.Strings) - 1
 if len(ms.Strings[last]) > 1 {
  ms.Strings[last] = ms.Strings[last][0 : len(ms.Strings[last])-1]
 }
}

func (ms *MakeString) EndsWith(ch rune) bool {
 s := ms.Strings[len(ms.Strings)-1]
 return len(s) > 0 && s[len(s)-1] == uint8(ch)
}

func (ms *MakeString) ReplaceLiteral(input string, output string) {
 for i := range ms.Strings {
  ms.Strings[i] = strings.Replace(ms.Strings[i], input, output, -1)
 }
}

// If MakeString is $(var) after trimming, returns var
func (ms *MakeString) SingleVariable() (*MakeString, bool) {
 if len(ms.Strings) != 2 || strings.TrimSpace(ms.Strings[0]) != "" ||
  strings.TrimSpace(ms.Strings[1]) != "" {
  return nil, false
 }
 return ms.Variables[0].Name, true
}

func splitAnyN(s, sep string, n int) []string {
 ret := []string{}
 for n == -1 || n > 1 {
  index := strings.IndexAny(s, sep)
  if index >= 0 {
   ret = append(ret, s[0:index])
   s = s[index+1:]
   if n > 0 {
    n--
   }
  } else {
   break
  }
 }
 ret = append(ret, s)
 return ret
}

func unescape(s string) string {
 ret := ""
 for {
  index := strings.IndexByte(s, '\\')
  if index < 0 {
   break
  }

  if index+1 == len(s) {
   break
  }

  switch s[index+1] {
  case ' ', '\\', '#', ':', '*', '[', '|', '\t', '\n', '\r':
   ret += s[:index] + s[index+1:index+2]
  default:
   ret += s[:index+2]
  }
  s = s[index+2:]
 }
 return ret + s
}