package bpdoc

import (
 "fmt"
 "reflect"
 "testing"
)

type propInfo struct {
 name string
 typ  string
}

type parentProps struct {
 A string

 Child *childProps

 Mutated *mutatedProps `blueprint:"mutated"`
}

type childProps struct {
 B int

 Child *grandchildProps
}

type grandchildProps struct {
 C bool
}

type mutatedProps struct {
 D int
}

func TestNestedPropertyStructs(t *testing.T) {
 parent := parentProps{Child: &childProps{Child: &grandchildProps{}}, Mutated: &mutatedProps{}}

 allStructs := nestedPropertyStructs(reflect.ValueOf(parent))

 // mutated shouldn't be found because it's a mutated property.
 expected := []string{"child", "child.child"}
 if len(allStructs) != len(expected) {
  t.Fatalf("expected %d structs, got %d, all entries: %v",
   len(expected), len(allStructs), allStructs)
 }
 got := []string{}
 for _, s := range allStructs {
  got = append(got, s.nestPoint)
 }

 if !reflect.DeepEqual(got, expected) {
  t.Errorf("Expected nested properties:\n\t %q,\n but got\n\t %q", expected, got)
 }
}

func TestAllPackages(t *testing.T) {
 packages, err := AllPackages(pkgFiles, moduleTypeNameFactories, moduleTypeNamePropertyStructs)
 if err != nil {
  t.Fatalf("expected nil error for AllPackages(%v, %v, %v), got %s", pkgFiles, moduleTypeNameFactories, moduleTypeNamePropertyStructs, err)
 }

 if numPackages := len(packages); numPackages != 1 {
  t.Errorf("Expected %d package, got %d packages %v instead", len(pkgFiles), numPackages, packages)
 }

 pkg := packages[0]

 expectedProps := map[string][]propInfo{
  "bar": []propInfo{
   propInfo{
    name: "a",
    typ:  "string",
   },
   propInfo{
    name: "nested",
    typ:  "",
   },
   propInfo{
    name: "nested.c",
    typ:  "string",
   },
   propInfo{
    name: "nested_struct",
    typ:  "structToNest",
   },
   propInfo{
    name: "nested_struct.e",
    typ:  "string",
   },
   propInfo{
    name: "struct_has_embed",
    typ:  "StructWithEmbedded",
   },
   propInfo{
    name: "struct_has_embed.nested_in_embedded",
    typ:  "structToNest",
   },
   propInfo{
    name: "struct_has_embed.nested_in_embedded.e",
    typ:  "string",
   },
   propInfo{
    name: "struct_has_embed.f",
    typ:  "string",
   },
   propInfo{
    name: "list_of_ints",
    typ:  "list of int",
   },
   propInfo{
    name: "list_of_nested",
    typ:  "list of structToNest",
   },
   propInfo{
    name: "configurable_bool",
    typ:  "configurable bool",
   },
   propInfo{
    name: "nested_in_other_embedded",
    typ:  "otherStructToNest",
   },
   propInfo{
    name: "nested_in_other_embedded.g",
    typ:  "string",
   },
   propInfo{
    name: "h",
    typ:  "string",
   },
  },
  "foo": []propInfo{
   propInfo{
    name: "a",
    typ:  "string",
   },
  },
 }

 for _, m := range pkg.ModuleTypes {
  foundProps := []propInfo{}

  for _, p := range m.PropertyStructs {
   nestedProps, errs := findAllProperties("", p.Properties)
   foundProps = append(foundProps, nestedProps...)
   for _, err := range errs {
    t.Errorf("%s", err)
   }
  }
  if wanted, ok := expectedProps[m.Name]; ok {
   if !reflect.DeepEqual(foundProps, wanted) {
    t.Errorf("For %s, expected\n\t %q,\nbut got\n\t %q", m.Name, wanted, foundProps)
   }
  }
 }
}

func findAllProperties(prefix string, properties []Property) ([]propInfo, []error) {
 foundProps := []propInfo{}
 errs := []error{}
 for _, p := range properties {
  prop := propInfo{
   name: prefix + p.Name,
   typ:  p.Type,
  }
  foundProps = append(foundProps, prop)
  if hasTag(p.Tag, "blueprint", "mutated") {
   err := fmt.Errorf("Property %s has `blueprint:\"mutated\" tag but should have been excluded.", p.Name)
   errs = append(errs, err)
  }

  nestedProps, nestedErrs := findAllProperties(prefix+p.Name+".", p.Properties)
  foundProps = append(foundProps, nestedProps...)
  errs = append(errs, nestedErrs...)
 }
 return foundProps, errs
}