// Copyright (C) 2019 The Android Open Source Project
//
// 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 sdk

import (
 "fmt"
 "reflect"
 "strings"

 "android/soong/android"
)

type bpPropertySet struct {
 properties map[string]interface{}
 tags       map[string]android.BpPropertyTag
 comments   map[string]string
 order      []string
}

var _ android.BpPropertySet = (*bpPropertySet)(nil)

func (s *bpPropertySet) init() {
 s.properties = make(map[string]interface{})
 s.tags = make(map[string]android.BpPropertyTag)
}

// Converts the given value, which is assumed to be a struct, to a
// bpPropertySet.
func convertToPropertySet(value reflect.Value) *bpPropertySet {
 res := newPropertySet()
 structType := value.Type()

 for i := 0; i < structType.NumField(); i++ {
  field := structType.Field(i)
  fieldVal := value.Field(i)

  switch fieldVal.Type().Kind() {
  case reflect.Ptr:
   if fieldVal.IsNil() {
    continue // nil pointer means the property isn't set.
   }
   fieldVal = fieldVal.Elem()
  case reflect.Slice:
   if fieldVal.IsNil() {
    continue // Ignore a nil slice (but not one with length zero).
   }
  }

  if fieldVal.Type().Kind() == reflect.Struct {
   fieldVal = fieldVal.Addr() // Avoid struct copy below.
  }
  res.AddProperty(strings.ToLower(field.Name), fieldVal.Interface())
 }

 return res
}

// Converts the given value to something that can be set in a property.
func coercePropertyValue(value interface{}) interface{} {
 val := reflect.ValueOf(value)
 switch val.Kind() {
 case reflect.Struct:
  // convertToPropertySet requires an addressable struct, and this is probably
  // a mistake.
  panic(fmt.Sprintf("Value is a struct, not a pointer to one: %v", value))
 case reflect.Ptr:
  if _, ok := value.(*bpPropertySet); !ok {
   derefValue := reflect.Indirect(val)
   if derefValue.Kind() != reflect.Struct {
    panic(fmt.Sprintf("A pointer must be to a struct, got: %v", value))
   }
   return convertToPropertySet(derefValue)
  }
 }
 return value
}

// Merges the fields of the given property set into s.
func (s *bpPropertySet) mergePropertySet(propSet *bpPropertySet) {
 for _, name := range propSet.order {
  if tag, ok := propSet.tags[name]; ok {
   s.AddPropertyWithTag(name, propSet.properties[name], tag)
  } else {
   s.AddProperty(name, propSet.properties[name])
  }
 }
}

func (s *bpPropertySet) AddProperty(name string, value interface{}) {
 value = coercePropertyValue(value)

 if propSetValue, ok := value.(*bpPropertySet); ok {
  if curValue, ok := s.properties[name]; ok {
   if curSet, ok := curValue.(*bpPropertySet); ok {
    curSet.mergePropertySet(propSetValue)
    return
   }
   // If the current value isn't a property set we got conflicting types.
   // Continue down to the check below to complain about it.
  }
 }

 if s.properties[name] != nil {
  panic(fmt.Sprintf("Property %q already exists in property set", name))
 }

 s.properties[name] = value
 s.order = append(s.order, name)
}

func (s *bpPropertySet) AddPropertyWithTag(name string, value interface{}, tag android.BpPropertyTag) {
 s.AddProperty(name, value)
 s.tags[name] = tag
}

func (s *bpPropertySet) AddPropertySet(name string) android.BpPropertySet {
 s.AddProperty(name, newPropertySet())
 return s.properties[name].(android.BpPropertySet)
}

func (s *bpPropertySet) getValue(name string) interface{} {
 return s.properties[name]
}

func (s *bpPropertySet) getOptionalValue(name string) (interface{}, bool) {
 value, ok := s.properties[name]
 return value, ok
}

func (s *bpPropertySet) getTag(name string) interface{} {
 return s.tags[name]
}

func (s *bpPropertySet) AddCommentForProperty(name, text string) {
 if s.comments == nil {
  s.comments = map[string]string{}
 }
 s.comments[name] = strings.TrimSpace(text)
}

func (s *bpPropertySet) transformContents(transformer bpPropertyTransformer) {
 var newOrder []string
 for _, name := range s.order {
  value := s.properties[name]
  tag := s.tags[name]
  var newValue interface{}
  var newTag android.BpPropertyTag
  if propertySet, ok := value.(*bpPropertySet); ok {
   var newPropertySet *bpPropertySet
   newPropertySet, newTag = transformPropertySet(transformer, name, propertySet, tag)
   if newPropertySet == nil {
    newValue = nil
   } else {
    newValue = newPropertySet
   }
  } else {
   newValue, newTag = transformer.transformProperty(name, value, tag)
  }

  if newValue == nil {
   // Delete the property from the map and exclude it from the new order.
   delete(s.properties, name)
  } else {
   // Update the property in the map and add the name to the new order list.
   s.properties[name] = newValue
   s.tags[name] = newTag
   newOrder = append(newOrder, name)
  }
 }
 s.order = newOrder
}

func transformPropertySet(transformer bpPropertyTransformer, name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) {
 newPropertySet, newTag := transformer.transformPropertySetBeforeContents(name, propertySet, tag)
 if newPropertySet != nil {
  newPropertySet.transformContents(transformer)

  newPropertySet, newTag = transformer.transformPropertySetAfterContents(name, newPropertySet, newTag)
 }
 return newPropertySet, newTag
}

func (s *bpPropertySet) setProperty(name string, value interface{}) {
 if s.properties[name] == nil {
  s.AddProperty(name, value)
 } else {
  s.properties[name] = value
  s.tags[name] = nil
 }
}

func (s *bpPropertySet) removeProperty(name string) {
 delete(s.properties, name)
 delete(s.tags, name)
 _, s.order = android.RemoveFromList(name, s.order)
}

func (s *bpPropertySet) insertAfter(position string, name string, value interface{}) {
 if s.properties[name] != nil {
  panic("Property %q already exists in property set")
 }

 // Add the name to the end of the order, to ensure it has necessary capacity
 // and to handle the case when the position does not exist.
 s.order = append(s.order, name)

 // Search through the order for the item that matches supplied position. If
 // found then insert the name of the new property after it.
 for i, v := range s.order {
  if v == position {
   // Copy the items after the one where the new property should be inserted.
   copy(s.order[i+2:], s.order[i+1:])
   // Insert the item in the list.
   s.order[i+1] = name
  }
 }

 s.properties[name] = value
}

type bpModule struct {
 *bpPropertySet
 moduleType string
}

func (m *bpModule) ModuleType() string {
 return m.moduleType
}

func (m *bpModule) Name() string {
 name, hasName := m.getOptionalValue("name")
 if hasName {
  return name.(string)
 } else {
  return ""
 }
}

var _ android.BpModule = (*bpModule)(nil)

type bpPropertyTransformer interface {
 // Transform the property set, returning the new property set/tag to insert back into the
 // parent property set (or module if this is the top level property set).
 //
 // This will be called before transforming the properties in the supplied set.
 //
 // The name will be "" for the top level property set.
 //
 // Returning (nil, ...) will cause the property set to be removed.
 transformPropertySetBeforeContents(name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag)

 // Transform the property set, returning the new property set/tag to insert back into the
 // parent property set (or module if this is the top level property set).
 //
 // This will be called after transforming the properties in the supplied set.
 //
 // The name will be "" for the top level property set.
 //
 // Returning (nil, ...) will cause the property set to be removed.
 transformPropertySetAfterContents(name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag)

 // Transform a property, return the new value/tag to insert back into the property set.
 //
 // Returning (nil, ...) will cause the property to be removed.
 transformProperty(name string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag)
}

// Interface for transforming bpModule objects.
type bpTransformer interface {
 // Transform the module, returning the result.
 //
 // The method can either create a new module and return that, or modify the supplied module
 // in place and return that.
 //
 // After this returns the transformer is applied to the contents of the returned module.
 transformModule(module *bpModule) *bpModule

 bpPropertyTransformer
}

type identityTransformation struct{}

var _ bpTransformer = (*identityTransformation)(nil)

func (t identityTransformation) transformModule(module *bpModule) *bpModule {
 return module
}

func (t identityTransformation) transformPropertySetBeforeContents(_ string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) {
 return propertySet, tag
}

func (t identityTransformation) transformPropertySetAfterContents(_ string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) {
 return propertySet, tag
}

func (t identityTransformation) transformProperty(_ string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag) {
 return value, tag
}

func (m *bpModule) deepCopy() *bpModule {
 return transformModule(m, deepCopyTransformer)
}

func transformModule(m *bpModule, transformer bpTransformer) *bpModule {
 transformedModule := transformer.transformModule(m)
 if transformedModule != nil {
  // Copy the contents of the returned property set into the module and then transform that.
  transformedModule.bpPropertySet, _ = transformPropertySet(transformer, "", transformedModule.bpPropertySet, nil)
 }
 return transformedModule
}

type deepCopyTransformation struct {
 identityTransformation
}

func (t deepCopyTransformation) transformModule(module *bpModule) *bpModule {
 // Take a shallow copy of the module. Any mutable property values will be copied by the
 // transformer.
 moduleCopy := *module
 return &moduleCopy
}

func (t deepCopyTransformation) transformPropertySetBeforeContents(_ string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) {
 // Create a shallow copy of the properties map. Any mutable property values will be copied by the
 // transformer.
 propertiesCopy := make(map[string]interface{})
 for propertyName, value := range propertySet.properties {
  propertiesCopy[propertyName] = value
 }

 // Ditto for tags map.
 tagsCopy := make(map[string]android.BpPropertyTag)
 for propertyName, propertyTag := range propertySet.tags {
  tagsCopy[propertyName] = propertyTag
 }

 // Create a new property set.
 return &bpPropertySet{
  properties: propertiesCopy,
  tags:       tagsCopy,
  order:      append([]string(nil), propertySet.order...),
 }, tag
}

func (t deepCopyTransformation) transformProperty(_ string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag) {
 // Copy string slice, otherwise return value.
 if values, ok := value.([]string); ok {
  valuesCopy := make([]string, len(values))
  copy(valuesCopy, values)
  return valuesCopy, tag
 }
 return value, tag
}

var deepCopyTransformer bpTransformer = deepCopyTransformation{}

// A .bp file
type bpFile struct {
 modules map[string]*bpModule
 order   []*bpModule
}

// AddModule adds a module to this.
//
// The module must have had its "name" property set to a string value that
// is unique within this file.
func (f *bpFile) AddModule(module android.BpModule) {
 m := module.(*bpModule)
 moduleType := module.ModuleType()
 name := m.Name()
 hasName := true
 if name == "" {
  // Use a prefixed module type as the name instead just in case this is something like a package
  // of namespace module which does not require a name.
  name = "#" + moduleType
  hasName = false
 }

 if f.modules[name] != nil {
  if hasName {
   panic(fmt.Sprintf("Module %q already exists in bp file", name))
  } else {
   panic(fmt.Sprintf("Unnamed module type %q already exists in bp file", moduleType))
  }
 }

 f.modules[name] = m
 f.order = append(f.order, m)
}

func (f *bpFile) newModule(moduleType string) *bpModule {
 return newModule(moduleType)
}

func newModule(moduleType string) *bpModule {
 module := &bpModule{
  moduleType:    moduleType,
  bpPropertySet: newPropertySet(),
 }
 return module
}

func newPropertySet() *bpPropertySet {
 set := &bpPropertySet{}
 set.init()
 return set
}