// Copyright 2014 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 proptools

import (
 "fmt"
 "reflect"
 "sync"
)

// CloneProperties takes a reflect.Value of a pointer to a struct and returns a reflect.Value
// of a pointer to a new struct that copies of the values for its fields.  It recursively clones
// struct pointers and interfaces that contain struct pointers.
func CloneProperties(structValue reflect.Value) reflect.Value {
 if !isStructPtr(structValue.Type()) {
  panic(fmt.Errorf("CloneProperties expected *struct, got %s", structValue.Type()))
 }
 result := reflect.New(structValue.Type().Elem())
 copyProperties(result.Elem(), structValue.Elem())
 return result
}

// CopyProperties takes destination and source reflect.Values of a pointer to structs and returns
// copies each field from the source into the destination.  It recursively copies struct pointers
// and interfaces that contain struct pointers.
func CopyProperties(dstValue, srcValue reflect.Value) {
 if !isStructPtr(dstValue.Type()) {
  panic(fmt.Errorf("CopyProperties expected dstValue *struct, got %s", dstValue.Type()))
 }
 if !isStructPtr(srcValue.Type()) {
  panic(fmt.Errorf("CopyProperties expected srcValue *struct, got %s", srcValue.Type()))
 }
 copyProperties(dstValue.Elem(), srcValue.Elem())
}

func copyProperties(dstValue, srcValue reflect.Value) {
 typ := dstValue.Type()
 if srcValue.Type() != typ {
  panic(fmt.Errorf("can't copy mismatching types (%s <- %s)",
   dstValue.Kind(), srcValue.Kind()))
 }

 for i, field := range typeFields(typ) {
  if field.PkgPath != "" {
   panic(fmt.Errorf("can't copy a private field %q", field.Name))
  }

  srcFieldValue := srcValue.Field(i)
  dstFieldValue := dstValue.Field(i)
  dstFieldInterfaceValue := reflect.Value{}
  origDstFieldValue := dstFieldValue

  switch srcFieldValue.Kind() {
  case reflect.Bool, reflect.String, reflect.Int, reflect.Uint:
   dstFieldValue.Set(srcFieldValue)
  case reflect.Struct:
   if isConfigurable(srcFieldValue.Type()) {
    dstFieldValue.Set(reflect.ValueOf(srcFieldValue.Interface().(configurableReflection).clone()))
   } else {
    copyProperties(dstFieldValue, srcFieldValue)
   }
  case reflect.Slice:
   if !srcFieldValue.IsNil() {
    if srcFieldValue != dstFieldValue {
     newSlice := reflect.MakeSlice(field.Type, srcFieldValue.Len(),
      srcFieldValue.Len())
     reflect.Copy(newSlice, srcFieldValue)
     dstFieldValue.Set(newSlice)
    }
   } else {
    dstFieldValue.Set(srcFieldValue)
   }
  case reflect.Map:
   if !srcFieldValue.IsNil() {
    newMap := reflect.MakeMap(field.Type)

    iter := srcFieldValue.MapRange()
    for iter.Next() {
     newMap.SetMapIndex(iter.Key(), iter.Value())
    }
    dstFieldValue.Set(newMap)
   } else {
    dstFieldValue.Set(srcFieldValue)
   }
  case reflect.Interface:
   if srcFieldValue.IsNil() {
    dstFieldValue.Set(srcFieldValue)
    break
   }

   srcFieldValue = srcFieldValue.Elem()

   if !isStructPtr(srcFieldValue.Type()) {
    panic(fmt.Errorf("can't clone field %q: expected interface to contain *struct, found %s",
     field.Name, srcFieldValue.Type()))
   }

   if dstFieldValue.IsNil() || dstFieldValue.Elem().Type() != srcFieldValue.Type() {
    // We can't use the existing destination allocation, so
    // clone a new one.
    newValue := reflect.New(srcFieldValue.Type()).Elem()
    dstFieldValue.Set(newValue)
    dstFieldInterfaceValue = dstFieldValue
    dstFieldValue = newValue
   } else {
    dstFieldValue = dstFieldValue.Elem()
   }
   fallthrough
  case reflect.Ptr:
   if srcFieldValue.IsNil() {
    origDstFieldValue.Set(srcFieldValue)
    break
   }

   switch srcFieldValue.Elem().Kind() {
   case reflect.Struct:
    if !dstFieldValue.IsNil() {
     // Re-use the existing allocation.
     copyProperties(dstFieldValue.Elem(), srcFieldValue.Elem())
     break
    } else {
     newValue := CloneProperties(srcFieldValue)
     if dstFieldInterfaceValue.IsValid() {
      dstFieldInterfaceValue.Set(newValue)
     } else {
      origDstFieldValue.Set(newValue)
     }
    }
   case reflect.Bool, reflect.Int64, reflect.String:
    newValue := reflect.New(srcFieldValue.Elem().Type())
    newValue.Elem().Set(srcFieldValue.Elem())
    origDstFieldValue.Set(newValue)
   default:
    panic(fmt.Errorf("can't clone pointer field %q type %s",
     field.Name, srcFieldValue.Type()))
   }
  default:
   panic(fmt.Errorf("unexpected type for property struct field %q: %s",
    field.Name, srcFieldValue.Type()))
  }
 }
}

// ZeroProperties takes a reflect.Value of a pointer to a struct and replaces all of its fields
// with zero values, recursing into struct, pointer to struct and interface fields.
func ZeroProperties(structValue reflect.Value) {
 if !isStructPtr(structValue.Type()) {
  panic(fmt.Errorf("ZeroProperties expected *struct, got %s", structValue.Type()))
 }
 zeroProperties(structValue.Elem())
}

func zeroProperties(structValue reflect.Value) {
 typ := structValue.Type()

 for i, field := range typeFields(typ) {
  if field.PkgPath != "" {
   // The field is not exported so just skip it.
   continue
  }

  fieldValue := structValue.Field(i)

  switch fieldValue.Kind() {
  case reflect.Bool, reflect.String, reflect.Slice, reflect.Int, reflect.Uint, reflect.Map:
   fieldValue.Set(reflect.Zero(fieldValue.Type()))
  case reflect.Interface:
   if fieldValue.IsNil() {
    break
   }

   // We leave the pointer intact and zero out the struct that's
   // pointed to.
   fieldValue = fieldValue.Elem()
   if !isStructPtr(fieldValue.Type()) {
    panic(fmt.Errorf("can't zero field %q: expected interface to contain *struct, found %s",
     field.Name, fieldValue.Type()))
   }
   fallthrough
  case reflect.Ptr:
   switch fieldValue.Type().Elem().Kind() {
   case reflect.Struct:
    if fieldValue.IsNil() {
     break
    }
    zeroProperties(fieldValue.Elem())
   case reflect.Bool, reflect.Int64, reflect.String:
    fieldValue.Set(reflect.Zero(fieldValue.Type()))
   default:
    panic(fmt.Errorf("can't zero field %q: points to a %s",
     field.Name, fieldValue.Elem().Kind()))
   }
  case reflect.Struct:
   zeroProperties(fieldValue)
  default:
   panic(fmt.Errorf("unexpected kind for property struct field %q: %s",
    field.Name, fieldValue.Kind()))
  }
 }
}

// CloneEmptyProperties takes a reflect.Value of a pointer to a struct and returns a reflect.Value
// of a pointer to a new struct that has the zero values for its fields.  It recursively clones
// struct pointers and interfaces that contain struct pointers.
func CloneEmptyProperties(structValue reflect.Value) reflect.Value {
 if !isStructPtr(structValue.Type()) {
  panic(fmt.Errorf("CloneEmptyProperties expected *struct, got %s", structValue.Type()))
 }
 result := reflect.New(structValue.Type().Elem())
 cloneEmptyProperties(result.Elem(), structValue.Elem())
 return result
}

func cloneEmptyProperties(dstValue, srcValue reflect.Value) {
 typ := srcValue.Type()
 for i, field := range typeFields(typ) {
  if field.PkgPath != "" {
   // The field is not exported so just skip it.
   continue
  }

  srcFieldValue := srcValue.Field(i)
  dstFieldValue := dstValue.Field(i)
  dstFieldInterfaceValue := reflect.Value{}

  switch srcFieldValue.Kind() {
  case reflect.Bool, reflect.String, reflect.Slice, reflect.Map, reflect.Int, reflect.Uint:
   // Nothing
  case reflect.Struct:
   cloneEmptyProperties(dstFieldValue, srcFieldValue)
  case reflect.Interface:
   if srcFieldValue.IsNil() {
    break
   }

   srcFieldValue = srcFieldValue.Elem()
   if !isStructPtr(srcFieldValue.Type()) {
    panic(fmt.Errorf("can't clone empty field %q: expected interface to contain *struct, found %s",
     field.Name, srcFieldValue.Type()))
   }

   newValue := reflect.New(srcFieldValue.Type()).Elem()
   dstFieldValue.Set(newValue)
   dstFieldInterfaceValue = dstFieldValue
   dstFieldValue = newValue
   fallthrough
  case reflect.Ptr:
   switch srcFieldValue.Type().Elem().Kind() {
   case reflect.Struct:
    if srcFieldValue.IsNil() {
     break
    }
    newValue := CloneEmptyProperties(srcFieldValue)
    if dstFieldInterfaceValue.IsValid() {
     dstFieldInterfaceValue.Set(newValue)
    } else {
     dstFieldValue.Set(newValue)
    }
   case reflect.Bool, reflect.Int64, reflect.String:
    // Nothing
   default:
    panic(fmt.Errorf("can't clone empty field %q: points to a %s",
     field.Name, srcFieldValue.Elem().Kind()))
   }

  default:
   panic(fmt.Errorf("unexpected kind for property struct field %q: %s",
    field.Name, srcFieldValue.Kind()))
  }
 }
}

var typeFieldCache sync.Map

func typeFields(typ reflect.Type) []reflect.StructField {
 // reflect.Type.Field allocates a []int{} to hold the index every time it is called, which ends up
 // being a significant portion of the GC pressure.  It can't reuse the same one in case a caller
 // modifies the backing array through the slice.  Since we don't modify it, cache the result
 // locally to reduce allocations.

 // Fast path
 if typeFields, ok := typeFieldCache.Load(typ); ok {
  return typeFields.([]reflect.StructField)
 }

 // Slow path
 typeFields := make([]reflect.StructField, typ.NumField())

 for i := range typeFields {
  typeFields[i] = typ.Field(i)
 }

 typeFieldCache.Store(typ, typeFields)

 return typeFields
}