"use strict";

const { ServiceBroker } = require("moleculer");
const { MoleculerClientError } = require("moleculer").Errors;

const ApiGateway = require("moleculer-web");
const { ApolloService } = require("../../index");

const broker = new ServiceBroker({
	logLevel: "info",
	tracing: {
		enabled: true,
		exporter: {
			type: "Console"
		}
	}
});

broker.createService({
	name: "api",

	mixins: [
		// Gateway
		ApiGateway,

		// GraphQL Apollo Server
		ApolloService({
			// API Gateway route options
			routeOptions: {
				path: "/graphql",
				cors: true,
				mappingPolicy: "restrict"
			},

			checkActionVisibility: true,

			// https://www.apollographql.com/docs/apollo-server/api/apollo-server#options
			serverOptions: {}
		})
	],

	events: {
		"graphql.schema.updated"(ctx) {
			this.logger.info("Generated GraphQL schema:\n\n" + ctx.params.schema);
		}
	}
});

broker.createService({
	name: "greeter",

	actions: {
		hello: {
			graphql: {
				query: "hello: String!"
			},
			handler() {
				return "Hello Moleculer!";
			}
		},
		welcome: {
			graphql: {
				mutation: `
					welcome(
						name: String!
					): String!
				`
			},
			handler(ctx) {
				return `Hello ${ctx.params.name}`;
			}
		},

		update: {
			graphql: {
				mutation: "update(id: Int!): Boolean!"
			},
			async handler(ctx) {
				await ctx.broadcast("graphql.publish", { tag: "UPDATED", payload: ctx.params.id });

				return true;
			}
		},

		updated: {
			graphql: {
				subscription: "updated: Int!",
				tags: ["UPDATED"],
				filter: "greeter.updatedFilter"
			},
			handler(ctx) {
				return ctx.params.payload;
			}
		},

		delete: {
			graphql: {
				subscription: "delete: Int!",
				tags: ["DELETE"]
			},
			handler(ctx) {
				return ctx.params.payload;
			}
		},

		updatedFilter: {
			handler(ctx) {
				return ctx.params.payload % 2 === 0;
			}
		},

		danger: {
			graphql: {
				query: "danger: String!"
			},
			async handler() {
				throw new MoleculerClientError("I've said it's a danger action!", 422, "DANGER");
			}
		},

		secret: {
			visibility: "protected",
			graphql: {
				query: "secret: String!"
			},
			async handler() {
				return "! TOP SECRET !";
			}
		},

		visible: {
			visibility: "published",
			graphql: {
				query: "visible: String!"
			},
			async handler() {
				return "Not secret";
			}
		}
	}
});

broker.start().then(async () => {
	broker.repl();

	const res = await broker.call("api.graphql", {
		query: "query { hello }"
	});

	if (res.errors && res.errors.length > 0) return res.errors.forEach(broker.logger.error);

	broker.logger.info(res.data);

	broker.logger.info("----------------------------------------------------------");
	broker.logger.info("Open the http://localhost:3000/graphql URL in your browser");
	broker.logger.info("----------------------------------------------------------");

	let counter = 1;
	setInterval(
		async () => broker.broadcast("graphql.publish", { tag: "UPDATED", payload: counter++ }),
		2000
	);
});