types

var FeatureTestInputType = graphql.NewInputObject(graphql.InputObjectConfig{
	Name: "FeatureTestInput",
	Fields: graphql.InputObjectConfigFieldMap{
		"name": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.String),
		},
		"startTime": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.DateTime),
		},
		"endTime": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.DateTime),
		},
		"variants": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.NewList(FeatureTestVariantInputType)),
		},
	},
})

var FeatureTestType = graphql.NewObject(graphql.ObjectConfig{
	Name: "FeatureTest",
	Fields: graphql.Fields{
		"id":        &graphql.Field{Type: graphql.ID},
		"name":      &graphql.Field{Type: graphql.String},
		"createdAt": &graphql.Field{Type: graphql.DateTime},
		"updatedAt": &graphql.Field{Type: graphql.DateTime},
		"startTime": &graphql.Field{Type: graphql.DateTime},
		"endTime":   &graphql.Field{Type: graphql.DateTime},
	},
})

var FeatureTestVariantInputType = graphql.NewInputObject(graphql.InputObjectConfig{
	Name: "FeatureTestVariantInput",
	Fields: graphql.InputObjectConfigFieldMap{
		"name": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.String),
		},
		"percentage": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.Int),
		},
		"isControl": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.Boolean),
		},
	},
})

var FeatureTestVariantType = graphql.NewObject(graphql.ObjectConfig{
	Name: "FeatureTestVariant",
	Fields: graphql.Fields{
		"id":         &graphql.Field{Type: graphql.ID},
		"name":       &graphql.Field{Type: graphql.String},
		"createdAt":  &graphql.Field{Type: graphql.DateTime},
		"updatedAt":  &graphql.Field{Type: graphql.DateTime},
		"percentage": &graphql.Field{Type: graphql.Int},
		"isControl":  &graphql.Field{Type: graphql.Boolean},
		"featureTest": &graphql.Field{
			Type: FeatureTestType,
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				featureTestID := params.Source.(FeatureTestVariant).FeatureTestID
				featureTest := new(FeatureTest)
				err := dal.DB.Model(featureTest).Where("id = ?", featureTestID).First()
				if err != nil {
					fmt.Printf("Error retrieving feature test from test variant: %v", err)
					return nil, err
				}
				return featureTest, nil
			},
		},
	},
})

var RoleType = graphql.NewObject(graphql.ObjectConfig{
	Name: "Role",
	Fields: graphql.Fields{
		"id":   &graphql.Field{Type: graphql.Int},
		"name": &graphql.Field{Type: graphql.String},
	},
})

var UserFeatureTestVariantInputType = graphql.NewInputObject(graphql.InputObjectConfig{
	Name: "UserFeatureTestVariantInput",
	Fields: graphql.InputObjectConfigFieldMap{
		"userID": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.Int),
		},
		"featureTestVariantID": &graphql.InputObjectFieldConfig{
			Type: graphql.NewNonNull(graphql.Int),
		},
	},
})

var UserFeatureTestVariantType = graphql.NewObject(graphql.ObjectConfig{
	Name: "UserFeatureTestVariant",
	Fields: graphql.Fields{
		"id": &graphql.Field{
			Type: graphql.Int,
		},
		"userID": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				return params.Source.(UserToFeatureUserTestVariant).UserID, nil
			},
		},
		"featureTestVariantID": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				return params.Source.(UserToFeatureUserTestVariant).FeatureTestVariantID, nil
			},
		},
		"user": &graphql.Field{
			Type: UserType,
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				userID := params.Source.(UserToFeatureUserTestVariant).UserID
				user := User{ID: userID}
				err := dal.DB.Select(&user)
				if err != nil {
					fmt.Printf("Error retrieving user from user feature test variant: %v", err)
					return nil, err
				}

				return user, nil
			},
		},
		"featureTestVariant": &graphql.Field{
			Type: FeatureTestVariantType,
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				variantID := params.Source.(UserToFeatureUserTestVariant).FeatureTestVariantID
				variant := FeatureTestVariant{ID: variantID}
				err := dal.DB.Select(&variant)
				if err != nil {
					fmt.Printf("Error retrieving feature test variant from user feature test variant: %v", err)
					return nil, err
				}

				return variant, nil
			},
		},
	},
})

var UserType = graphql.NewObject(graphql.ObjectConfig{
	Name: "User",
	Fields: graphql.Fields{
		"id":        &graphql.Field{Type: graphql.Int},
		"firstname": &graphql.Field{Type: graphql.String},
		"lastname":  &graphql.Field{Type: graphql.String},
		"roles": &graphql.Field{
			Type: graphql.NewList(RoleType),
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				userID := params.Source.(User).ID
				user := new(User)
				err := dal.DB.Model(user).Where("id = ?", userID).Relation("Roles").First()
				if err != nil {
					fmt.Printf("Error retrieving user roles: %v", err)
					return nil, err
				}

				return user.Roles, nil
			},
		},
		"featureTestVariants": &graphql.Field{
			Type: graphql.NewList(FeatureTestVariantType),
			Resolve: func(params graphql.ResolveParams) (interface{}, error) {
				userID := params.Source.(User).ID
				user := new(User)
				err := dal.DB.Model(user).Where("id = ?", userID).Relation("FeatureTestVariants").First()
				if err != nil {
					fmt.Printf("Error retrieving user feature test variants: %v", err)
					return nil, err
				}
				return user.FeatureTestVariants, nil
			},
		},
	},
})