// Copyright 2024 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"
 "slices"

 "github.com/google/blueprint/parser"
)

func RepackProperties(props []interface{}) (*parser.Map, error) {

 var dereferencedProps []reflect.Value
 for _, rawProp := range props {
  propStruct := reflect.ValueOf(rawProp)
  if !isStructPtr(propStruct.Type()) {
   return nil, fmt.Errorf("properties must be *struct, got %s",
    propStruct.Type())
  }
  propStruct = propStruct.Elem()
  dereferencedProps = append(dereferencedProps, propStruct)
 }

 return repackStructs(dereferencedProps)
}

func repackStructs(props []reflect.Value) (*parser.Map, error) {
 var allFieldNames []string
 for _, prop := range props {
  propType := prop.Type()
  for i := 0; i < propType.NumField(); i++ {
   field := propType.Field(i)
   if !slices.Contains(allFieldNames, field.Name) {
    allFieldNames = append(allFieldNames, field.Name)
   }
  }
 }

 result := &parser.Map{}

 for _, fieldName := range allFieldNames {
  var fields []reflect.Value
  for _, prop := range props {
   field := prop.FieldByName(fieldName)
   if field.IsValid() {
    fields = append(fields, field)
   }
  }
  if err := assertFieldsEquivalent(fields); err != nil {
   return nil, err
  }

  var expr parser.Expression
  var field reflect.Value
  for _, f := range fields {
   if !isPropEmpty(f) {
    field = f
    break
   }
  }
  if !field.IsValid() {
   continue
  }
  if isStruct(field.Type()) && !isConfigurable(field.Type()) {
   x, err := repackStructs(fields)
   if err != nil {
    return nil, err
   }
   if x != nil {
    expr = x
   }
  } else {
   x, err := fieldToExpr(field)
   if err != nil {
    return nil, err
   }
   if x != nil {
    expr = *x
   }
  }

  if expr != nil {
   result.Properties = append(result.Properties, &parser.Property{
    Name:  PropertyNameForField(fieldName),
    Value: expr,
   })
  }
 }

 return result, nil
}

func fieldToExpr(field reflect.Value) (*parser.Expression, error) {
 if IsConfigurable(field.Type()) {
  return field.Interface().(configurableReflection).toExpression()
 }
 if field.Kind() == reflect.Pointer {
  if field.IsNil() {
   return nil, nil
  }
  field = field.Elem()
 }
 switch field.Kind() {
 case reflect.String:
  var result parser.Expression = &parser.String{Value: field.String()}
  return &result, nil
 case reflect.Bool:
  var result parser.Expression = &parser.Bool{Value: field.Bool()}
  return &result, nil
 case reflect.Int, reflect.Int64:
  var result parser.Expression = &parser.Int64{Value: field.Int()}
  return &result, nil
 case reflect.Slice:
  var contents []parser.Expression
  for i := 0; i < field.Len(); i++ {
   inner, err := fieldToExpr(field.Index(i))
   if err != nil {
    return nil, err
   }
   contents = append(contents, *inner)
  }
  var result parser.Expression = &parser.List{Values: contents}
  return &result, nil
 case reflect.Struct:
  var properties []*parser.Property
  typ := field.Type()
  for i := 0; i < typ.NumField(); i++ {
   inner, err := fieldToExpr(field.Field(i))
   if err != nil {
    return nil, err
   }
   properties = append(properties, &parser.Property{
    Name:  typ.Field(i).Name,
    Value: *inner,
   })
  }
  var result parser.Expression = &parser.Map{Properties: properties}
  return &result, nil
 default:
  return nil, fmt.Errorf("Unhandled type: %s", field.Kind().String())
 }
}

func isPropEmpty(value reflect.Value) bool {
 switch value.Kind() {
 case reflect.Pointer:
  if value.IsNil() {
   return true
  }
  return isPropEmpty(value.Elem())
 case reflect.Struct:
  if isConfigurable(value.Type()) {
   return value.Interface().(configurableReflection).isEmpty()
  }
  for i := 0; i < value.NumField(); i++ {
   if !isPropEmpty(value.Field(i)) {
    return false
   }
  }
  return true
 default:
  return false
 }
}

func assertFieldsEquivalent(fields []reflect.Value) error {
 var firstNonEmpty reflect.Value
 var firstIndex int
 for i, f := range fields {
  if !isPropEmpty(f) {
   firstNonEmpty = f
   firstIndex = i
   break
  }
 }
 if !firstNonEmpty.IsValid() {
  return nil
 }
 for i, f := range fields {
  if i != firstIndex && !isPropEmpty(f) {
   if err := assertTwoNonEmptyFieldsEquivalent(firstNonEmpty, f); err != nil {
    return err
   }
  }
 }
 return nil
}

func assertTwoNonEmptyFieldsEquivalent(a, b reflect.Value) error {
 aType := a.Type()
 bType := b.Type()

 if aType != bType {
  return fmt.Errorf("fields must have the same type")
 }

 switch aType.Kind() {
 case reflect.Pointer:
  return assertTwoNonEmptyFieldsEquivalent(a.Elem(), b.Elem())
 case reflect.String:
  if a.String() != b.String() {
   return fmt.Errorf("Conflicting fields in property structs had values %q and %q", a.String(), b.String())
  }
 case reflect.Bool:
  if a.Bool() != b.Bool() {
   return fmt.Errorf("Conflicting fields in property structs had values %t and %t", a.Bool(), b.Bool())
  }
 case reflect.Slice:
  if a.Len() != b.Len() {
   return fmt.Errorf("Conflicting fields in property structs had lengths %d and %d", a.Len(), b.Len())
  }
  for i := 0; i < a.Len(); i++ {
   if err := assertTwoNonEmptyFieldsEquivalent(a.Index(i), b.Index(i)); err != nil {
    return err
   }
  }
 case reflect.Int:
  if a.Int() != b.Int() {
   return fmt.Errorf("Conflicting fields in property structs had values %d and %d", a.Int(), b.Int())
  }
 case reflect.Struct:
  if isConfigurable(a.Type()) {
   // We could properly check that two configurables are equivalent, but that's a lot more
   // work for a case that I don't think should show up in practice.
   return fmt.Errorf("Cannot handle two property structs with nonempty configurable properties")
  }
  // We don't care about checking if structs are equivalent, we'll check their individual
  // fields when we recurse down.
 default:
  return fmt.Errorf("Unhandled kind: %s", aType.Kind().String())
 }

 return nil
}