// npm
import express from 'express';
import cookieParser from 'cookie-parser';
import bodyParser from 'body-parser';
import cors from 'cors';
import * as fs from 'fs';
import { v4 as uuid } from 'uuid';
import * as path from 'path';
import morgan from 'morgan';
import * as sinon from 'sinon';

// @ownzones
import { s3 as ownS3 } from '@ownzones/lib';
import { CognitoTokenVerifier, ICognitoTokenPayload } from '@ownzones/iam-service';
import { Server } from 'http';
import { IComposition, IFile } from '../../lib/connect-api';

interface GraphQLRequest {
  query: string;
  variables: Record<string, any>;
}

export interface IMockOrganization {
  slug: string,
  mediaViewCacheFileLocator: { url: string },
  organizationOptions: {
    cacheCapacity: string;
  };
  clearS3Cache(): Promise<void>
}

const organizations: Record<string, IMockOrganization> = {};
export const getOrCreateOrganization = (orgSlug: string): IMockOrganization => {
  if (!Object.prototype.hasOwnProperty.call(organizations, orgSlug)) {
    const url = `s3://oz-zl-test-files/mediaview/run/${uuid()}/mv-cache`;

    organizations[orgSlug] = {
      slug: orgSlug,
      mediaViewCacheFileLocator: { url },
      organizationOptions: {
        cacheCapacity: '0',
      },
      clearS3Cache: async () => { await ownS3.deleteFolder(url); },
    };
  }
  return organizations[orgSlug];
};

// parse all the composition definitions from the test/composition-definitions/ folder and index them by id
const compositionDefinitions: Record<string, IComposition> = {};
const compositionDefinitionsFolder = path.join(__dirname, '../composition-definitions');
for (const compositionPath of fs.readdirSync(compositionDefinitionsFolder)) {
  const composition = JSON.parse(fs.readFileSync(path.join(compositionDefinitionsFolder, compositionPath)).toString()) as IComposition;
  compositionDefinitions[composition.id] = composition;
}

// parse all the files from the test/test-files/ folder and index them by id
const files: Record<string, IFile> = {};
const filesFolder = path.join(__dirname, '../test-files');
for (const filePath of fs.readdirSync(filesFolder)) {
  const testFile = JSON.parse(fs.readFileSync(path.join(filesFolder, filePath)).toString()) as IFile;
  files[testFile.id] = testFile;
}

export function createTokenVerifierMock(): CognitoTokenVerifier {
  return sinon.createStubInstance(CognitoTokenVerifier, {
    verify: sinon.stub<[string], Promise<ICognitoTokenPayload>>()
      .resolves({ userId: '4567', email: 'gigi', sysAdmin: false }),
  }) as unknown as CognitoTokenVerifier;
}

export function connectApiInit(): Server {
  const app = express();
  app.use(cors());
  app.use(bodyParser());
  app.use(cookieParser());
  app.use(morgan('combined'));

  app.post('/graphql', (req: express.Request<unknown, any, GraphQLRequest>, res: express.Response): express.Response | null => {
    if (req.body.query?.includes('CompositionDefinition')) {
      const { fileId } = req.body.variables as { fileId: string };

      return res.json({
        data: {
          compositionDefinition: compositionDefinitions[fileId],
        },
      });
    }

    if (req.body.query?.includes('organizationBySlug')) {
      const { slug } = req.body.variables as { slug: string };
      const organization = getOrCreateOrganization(slug);
      const org = {
        data: {
          organizationBySlug: {
            ...organization,
          },
        },
      };
      return res.json(org);
    }

    if (req.body.query.includes('File')) {
      const { id } = req.body.variables as { id: string };

      return res.json({
        data: {
          file: files[id],
        },
      });
    }

    return null;
  });

  const zyplineServer = app.listen(4050);
  zyplineServer.setTimeout(10 * 60 * 1000);

  return zyplineServer;
}