import {createSchema} from "@vostro/gqlize";
// import {Op} from "sequelize";
import {getDatabase, getDataManager} from "@vostro/c2-utils/lib/database";
import logger from "@vostro/c2-utils/lib/logger";
import { C2Utils } from "@vostro/c2-utils/lib/types";
// import waterfall from "@vostro/c2-utils/lib/waterfall";
import { C2Engine } from '@vostro/c2-engine/lib/types';
const log = logger("setup:", "", module);

export default async function setup(settings: C2Engine.ApplicationSettings, ctx: C2Engine.CoreContext) {
  // const db = await getDatabase();
  const context: C2Utils.DataContext = {override: true};
  await createBaseSystemPermissions(context, ctx?.graphql?.schemas);
}
async function createBaseSystemPermissions(context:  C2Utils.DataContext, extend: any) {
  const sc = {
    model: {},
    query: {},
    mutation: {},
    subscription: {},
  } as any;
  const permission = {
    model(modelName: any) {
      sc.model[`${modelName}`] = true;
      return true;
    },
    field(modelName: any, fieldName: any) {
      sc.model[`${modelName}/${fieldName}`] = true;
      return true;
    },
    relationship(modelName: any, relationshipName: any, targetModelName: any) {
      sc.model[`${modelName}/${relationshipName}`] = true;
      return true;
    },
    query(modelName: any) {
      sc.query[`${modelName}`] = true;
      return true;
    },
    queryClassMethods(modelName: any, methodName: any) {
      sc.query[`${modelName}/${methodName}`] = true;
      return true;
    },
    queryInstanceMethods(modelName: any, methodName: any) {
      sc.model[`${modelName}/${methodName}`] = true;
      return true;
    },
    mutation(modelName: any) {
      sc.mutation[`${modelName}`] = true;
      return true;
    },
    mutationUpdate(modelName: any) {
      sc.mutation[`${modelName}/update`] = true;
      return true;
    },
    mutationUpdateInput(modelName: any, fieldName: any) {
      sc.mutation[`${modelName}/update/${fieldName}`] = true;
      return true;
    },
    mutationCreate(modelName: any) {
      sc.mutation[`${modelName}/create`] = true;
      return true;
    },
    mutationCreateInput(modelName: any, fieldName: any) {
      sc.mutation[`${modelName}/create/${fieldName}`] = true;
      return true;
    },
    mutationDelete(modelName: any) {
      sc.mutation[`${modelName}/destroy`] = true;
      return true;
    },
    mutationExtension(modelName: any) {
      sc.mutation[`extension/${modelName}`] = true;
      return true;
    },
    queryExtension(modelName: any) {
      sc.query[`extension/${modelName}`] = true;
      return true;
    },
    mutationClassMethods(modelName: any, methodName: any) {
      sc.mutation[`${modelName}/${methodName}`] = true;
      return true;
    },
    subscription(modelName: any, hookName: any) {
      sc.subscription[`${modelName}/${hookName}`] = true;
      return true;
    },
  };
  const instance = await getDataManager();
  const db = await getDatabase();
  await createSchema(instance, {
    permission,
    extend,
  });

  sc.other = createWhereOperatorPermissionList(instance);

  try {
    let q = "";
    Object.keys(sc.model).forEach((k) => {
      q += createUpsertPermission(k, "model");
    });
    Object.keys(sc.query).forEach((k) => {
      q += createUpsertPermission(k, "query");
    });

    Object.keys(sc.mutation).forEach((k) => {
      q += createUpsertPermission(k, "mutation");
    });
    Object.keys(sc.subscription).forEach((k) => {
      q += createUpsertPermission(k, "subscription");
    });
    Object.keys(sc.other).forEach((k) => {
      q += createUpsertPermission(k, "other");
    });
    await db.query(q);
  } catch (err) {
    log.error("ERRROR on permission bulkCreate", err);
  }
  log.info("sys-perms done");

}
export function createUpsertPermission(name: string, type: string) {
  return `INSERT INTO public.permissions("name", "type", "createdAt", "updatedAt") VALUES ('${name}', '${type}', now(), now()) ON CONFLICT ("name", "type") DO NOTHING;\n`;
}

const createWhereOperatorPermissionList = (instance: { defs: any; }) => {
  try {
    const instanceDefinitions = instance.defs || {};
    let whereOperators: any = {};
    Object.keys(instanceDefinitions).forEach(model => {
      Object.keys(instanceDefinitions[model].whereOperatorTypes || {}).forEach(whereOperator => {
        const permissionName = `${model}/${whereOperator}` 
        whereOperators[permissionName] = true;
      })
    })
    return whereOperators;
  } catch (e) {
    console.log(e)
    return {};  
  }
}