import { HttpModule } from "@nestjs/axios";
import {
  CanActivate,
  DynamicModule,
  ExecutionContext,
  HttpException,
  Injectable,
  mixin,
  Module,
} from "@nestjs/common";
import { Observable } from "rxjs";

var http = require("http");
var querystring = require("querystring");

export interface FirebackInstallationInfo {
  port?: number;
  hostname?: string;
}

export interface User {
  uniqueId: string;
}

export interface AccessLevel {
  capabilities: string[];
  workspaces: string[];
  sql: string;
}

export interface AuthResult {
  auth: {
    workspaceId: string;
    internalSql: string;
    userId: string;
    user: User;
    accessLevel: AccessLevel;
  };
}

export const WithWorkspace = (...permissions: string[]) => {
  @Injectable()
  class RoleGuardMixin implements CanActivate {
    // constructor(@Inject(CONFIG_OPTIONS) public options: any) {}

    canActivate(
      context: ExecutionContext
    ): boolean | Promise<boolean> | Observable<boolean> {
      //   console.log(200, this.options);
      const auth = context.switchToHttp().getRequest().headers["authorization"];

      if (!auth) {
        return false;
      }

      return authorize({}, auth, permissions).then((result: any) => {
        if (result.error) {
          throw new HttpException(result, 400);
        }

        context.switchToHttp().getRequest().auth = result;

        return true;
      });
    }
  }

  const guard = mixin(RoleGuardMixin);
  return guard;
};

export function authorize(
  connection: FirebackInstallationInfo,
  token: string,
  permissions: string[]
): Promise<boolean> {
  var postData = querystring.stringify({});

  var options = {
    hostname:
      connection.hostname || process.env.FIREBACK_HOSTNAME || "localhost",
    port: connection.port || process.env.FIREBACK_PORT || 4500,
    path: "/authorization",
    method: "POST",
    headers: {
      authorization: token,
      permissions: permissions.join(","),
      "Content-Type": "application/x-www-form-urlencoded",
      "Content-Length": postData.length,
    },
  };

  console.log(options);

  return new Promise((resolve, reject) => {
    var req = http.request(options, function (res) {
      let data = "";
      res.setEncoding("utf8");

      res.on("data", function (chunk) {
        data += chunk;
      });

      res.on("end", function () {
        let result = null;
        try {
          result = JSON.parse(data);
        } catch (err) {
          reject(err);
        }

        if (result === null) {
          reject();
        } else if (result?.data) {
          resolve(result.data);
        } else {
          reject(false);
        }
      });
    });

    req.on("error", function (e) {
      reject(e.message);
    });

    req.write(postData);
    req.end();
  });
}
export const CONFIG_OPTIONS = "CONFIG_OPTIONS";

@Module({})
export class FirebackModule {
  static register(config?: FirebackInstallationInfo): DynamicModule {
    return {
      module: FirebackModule,
      imports: [HttpModule],
      providers: [
        // {
        //   provide: CONFIG_OPTIONS,
        //   useValue: config,
        // },
        // {
        //   provide: WithWorkspace,
        //   useFactory: WithWorkspace,
        // },
      ],
      //   exports: [
      //     {
      //       provide: CONFIG_OPTIONS,
      //       useValue: config,
      //     },
      //   ],
    };
  }
}