package gql

import (
	"fmt"

	"github.com/graph-gophers/dataloader"
	"github.com/graphql-go/graphql"

	helper "git.kapelle.org/niklas/s3browser/internal/helper"
	types "git.kapelle.org/niklas/s3browser/internal/types"
	log "github.com/sirupsen/logrus"
)

//GraphqlSchema generate the schema with its root query and mutation
func GraphqlSchema() (graphql.Schema, error) {

	queryFields := graphql.Fields{
		"files": &graphql.Field{
			Type: graphql.NewNonNull(graphql.NewList(graphql.NewNonNull(graphqlFileType))),
			Args: graphql.FieldConfigArgument{
				"path": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if is, err := helper.IsAuth(p.Context); !is {
					return nil, err
				}

				path, ok := p.Args["path"].(string)

				if !ok {
					return nil, nil
				}

				log.Debug("querry 'files': ", path)

				loader := p.Context.Value("loader").(map[string]*dataloader.Loader)
				thunk := loader["getFiles"].Load(p.Context, dataloader.StringKey(path))
				return thunk()
			},
		},
		"directorys": &graphql.Field{
			Type: graphql.NewNonNull(graphql.NewList(graphql.NewNonNull(graphqlDirType))),
			Args: graphql.FieldConfigArgument{
				"path": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if is, err := helper.IsAuth(p.Context); !is {
					return nil, err
				}

				path, ok := p.Args["path"].(string)

				if !ok {
					return nil, nil
				}

				log.Debug("querry 'directorys': ", path)

				loader := p.Context.Value("loader").(map[string]*dataloader.Loader)
				thunk := loader["getDirs"].Load(p.Context, dataloader.StringKey(path))
				return thunk()
			},
		},
		"file": &graphql.Field{
			Type: graphqlFileType,
			Args: graphql.FieldConfigArgument{
				"id": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.ID),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if is, err := helper.IsAuth(p.Context); !is {
					return nil, err
				}

				id, ok := p.Args["id"].(string)
				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}

				log.Debug("querry 'file': ", id)

				return types.File{
					ID: id,
				}, nil
			},
		},
		"authorized": &graphql.Field{
			Name:        "authorized",
			Type:        graphql.NewNonNull(graphql.Boolean),
			Description: "True if the user is authorized",
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				auth, _ := helper.IsAuth(p.Context)

				return auth, nil
			},
		},
	}

	mutationFields := graphql.Fields{
		"delete": &graphql.Field{
			Type: graphql.String,
			Args: graphql.FieldConfigArgument{
				"id": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.ID),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if is, err := helper.IsAuth(p.Context); !is {
					return nil, err
				}

				id, ok := p.Args["id"].(string)
				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}

				log.Debug("mutation 'delete': ", id)

				return id, deleteMutation(p.Context, id)
			},
		},
		"copy": &graphql.Field{
			Type: graphqlFileType,
			Args: graphql.FieldConfigArgument{
				"src": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.ID),
				},
				"dest": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.ID),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if is, err := helper.IsAuth(p.Context); !is {
					return nil, err
				}

				src, ok := p.Args["src"].(string)
				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}
				dest, ok := p.Args["dest"].(string)
				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}

				log.Debug("mutation 'copy': ", src, "-->", dest)

				return copyMutation(p.Context, src, dest)
			},
		},
		"move": &graphql.Field{
			Type: graphqlFileType,
			Args: graphql.FieldConfigArgument{
				"src": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.ID),
				},
				"dest": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.ID),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if is, err := helper.IsAuth(p.Context); !is {
					return nil, err
				}

				src, ok := p.Args["src"].(string)
				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}
				dest, ok := p.Args["dest"].(string)
				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}

				log.Debug("mutation 'move': ", src, "-->", dest)

				return moveMutation(p.Context, src, dest)
			},
		},
		"createDir": &graphql.Field{
			Type: graphql.NewNonNull(graphqlDirType),
			Args: graphql.FieldConfigArgument{
				"path": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.ID),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if is, err := helper.IsAuth(p.Context); !is {
					return nil, err
				}

				path, ok := p.Args["path"].(string)
				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}

				log.Debug("mutation 'createDir': ", path)

				return createDirectory(p.Context, path)
			},
		},
		"deleteDir": &graphql.Field{
			Type: graphql.NewNonNull(graphql.String),
			Args: graphql.FieldConfigArgument{
				"path": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.ID),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				if is, err := helper.IsAuth(p.Context); !is {
					return nil, err
				}

				path, ok := p.Args["path"].(string)

				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}

				log.Debug("mutation 'deleteDir': ", path)

				return path, deleteDirectory(p.Context, path)
			},
		},
		"login": &graphql.Field{
			Type: graphql.NewNonNull(graphqlLoginResultType),
			Args: graphql.FieldConfigArgument{
				"username": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
				"password": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				username, ok := p.Args["username"].(string)

				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}

				password, ok := p.Args["password"].(string)

				if !ok {
					return nil, fmt.Errorf("Failed to parse args")
				}

				return login(p.Context, username, password)
			},
		},
	}

	rootQuery := graphql.ObjectConfig{
		Name:   "RootQuery",
		Fields: queryFields,
	}

	rootMutation := graphql.ObjectConfig{
		Name:   "RootMutation",
		Fields: mutationFields,
	}

	schemaConfig := graphql.SchemaConfig{
		Query:    graphql.NewObject(rootQuery),
		Mutation: graphql.NewObject(rootMutation),
	}

	return graphql.NewSchema(schemaConfig)
}