import * as plugins from '../plugins.js';
import * as crypto from 'node:crypto';
import * as nodeStream from 'node:stream';
import type { Cloudly } from '../classes.cloudly.js';
import { logger } from '../logger.js';
import {
  BaseOsNode,
  type IBaseOsDesiredState,
  type IBaseOsNodePublic,
  type IBaseOsRuntimeInfo,
} from './classes.baseosnode.js';
import {
  BaseOsImageBuild,
  type IBaseOsImageArtifact,
  type IBaseOsImageBuildPublic,
  type TBaseOsImageArchitecture,
} from './classes.baseosimagebuild.js';

interface IBaseOsRegisterRequest {
  joinToken?: string;
  nodeToken?: string;
  status?: IBaseOsRuntimeInfo;
}

interface IBaseOsRegisterResponse {
  nodeId?: string;
  nodeToken?: string;
  accepted: boolean;
  message?: string;
}

interface IBaseOsHeartbeatRequest {
  nodeToken?: string;
  status?: IBaseOsRuntimeInfo;
}

interface IBaseOsHeartbeatResponse {
  accepted: boolean;
  message?: string;
  desiredState?: IBaseOsDesiredState;
}

interface IRequestGetBaseOsNodes {
  method: 'getBaseOsNodes';
  request: {
    identity: plugins.servezoneInterfaces.data.IIdentity;
  };
  response: {
    nodes: IBaseOsNodePublic[];
  };
}

interface IBaseOsImageBuildRequest {
  architecture: TBaseOsImageArchitecture;
  cloudlyUrl?: string;
  sourceImageUrl?: string;
  ubuntuVersion?: string;
  hostname?: string;
  wifi?: {
    ssid: string;
    password?: string;
  };
  sshPublicKey?: string;
  artifactRetentionMs?: number;
}

interface IRequestCreateBaseOsImageBuild {
  method: 'createBaseOsImageBuild';
  request: {
    identity: plugins.servezoneInterfaces.data.IIdentity;
    build: IBaseOsImageBuildRequest;
  };
  response: {
    build: IBaseOsImageBuildPublic;
  };
}

interface IRequestGetBaseOsImageBuilds {
  method: 'getBaseOsImageBuilds';
  request: {
    identity: plugins.servezoneInterfaces.data.IIdentity;
  };
  response: {
    builds: IBaseOsImageBuildPublic[];
  };
}

interface IRequestGetBaseOsImageBuildById {
  method: 'getBaseOsImageBuildById';
  request: {
    identity: plugins.servezoneInterfaces.data.IIdentity;
    buildId: string;
  };
  response: {
    build: IBaseOsImageBuildPublic;
  };
}

interface IRequestCreateBaseOsImageDownloadUrl {
  method: 'createBaseOsImageDownloadUrl';
  request: {
    identity: plugins.servezoneInterfaces.data.IIdentity;
    buildId: string;
  };
  response: {
    url: string;
    expiresAt: number;
  };
}

interface ICoreBuildBaseOsImageResponse {
  success: boolean;
  artifact?: IBaseOsImageArtifact;
  logs: string[];
  errorText?: string;
}

export class CloudlyBaseOsManager {
  public cloudlyRef: Cloudly;
  public typedRouter = new plugins.typedrequest.TypedRouter();

  public get db() {
    return this.cloudlyRef.mongodbConnector.smartdataDb;
  }

  public CBaseOsNode = plugins.smartdata.setDefaultManagerForDoc(this, BaseOsNode);
  public CBaseOsImageBuild = plugins.smartdata.setDefaultManagerForDoc(this, BaseOsImageBuild);

  constructor(cloudlyRefArg: Cloudly) {
    this.cloudlyRef = cloudlyRefArg;
    this.cloudlyRef.typedrouter.addTypedRouter(this.typedRouter);

    this.typedRouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<IRequestGetBaseOsNodes>(
        'getBaseOsNodes',
        async (requestDataArg) => {
          await plugins.smartguard.passGuardsOrReject(
            { identity: requestDataArg.identity },
            [this.cloudlyRef.authManager.adminIdentityGuard],
          );
          return {
            nodes: await this.getPublicNodes(),
          };
        },
      ),
    );

    this.typedRouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<IRequestCreateBaseOsImageBuild>(
        'createBaseOsImageBuild',
        async (requestDataArg) => {
          await plugins.smartguard.passGuardsOrReject(
            { identity: requestDataArg.identity },
            [this.cloudlyRef.authManager.adminIdentityGuard],
          );
          return {
            build: await this.createImageBuild(requestDataArg.build),
          };
        },
      ),
    );

    this.typedRouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<IRequestGetBaseOsImageBuilds>(
        'getBaseOsImageBuilds',
        async (requestDataArg) => {
          await plugins.smartguard.passGuardsOrReject(
            { identity: requestDataArg.identity },
            [this.cloudlyRef.authManager.adminIdentityGuard],
          );
          return {
            builds: await this.getPublicImageBuilds(),
          };
        },
      ),
    );

    this.typedRouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<IRequestGetBaseOsImageBuildById>(
        'getBaseOsImageBuildById',
        async (requestDataArg) => {
          await plugins.smartguard.passGuardsOrReject(
            { identity: requestDataArg.identity },
            [this.cloudlyRef.authManager.adminIdentityGuard],
          );
          return {
            build: (await this.getImageBuildById(requestDataArg.buildId)).toPublicBuild(),
          };
        },
      ),
    );

    this.typedRouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<IRequestCreateBaseOsImageDownloadUrl>(
        'createBaseOsImageDownloadUrl',
        async (requestDataArg) => {
          await plugins.smartguard.passGuardsOrReject(
            { identity: requestDataArg.identity },
            [this.cloudlyRef.authManager.adminIdentityGuard],
          );
          return await this.createImageDownloadUrl(requestDataArg.buildId);
        },
      ),
    );
  }

  public async start() {
    logger.log('info', 'BaseOS manager started');
  }

  public async stop() {
    logger.log('info', 'BaseOS manager stopped');
  }

  public async handleRegisterHttpRequest(
    reqArg: plugins.typedserver.Request,
    resArg: plugins.typedserver.Response,
  ) {
    try {
      const requestData = await this.readJsonBody<IBaseOsRegisterRequest>(reqArg);
      const response = await this.registerNode(requestData);
      this.sendJson(resArg, 200, response);
    } catch (error) {
      this.sendJson(resArg, 400, {
        accepted: false,
        message: `BaseOS registration failed: ${(error as Error).message}`,
      } satisfies IBaseOsRegisterResponse);
    }
  }

  public async handleHeartbeatHttpRequest(
    reqArg: plugins.typedserver.Request,
    resArg: plugins.typedserver.Response,
  ) {
    try {
      const requestData = await this.readJsonBody<IBaseOsHeartbeatRequest>(reqArg);
      const response = await this.acceptHeartbeat(requestData);
      this.sendJson(resArg, 200, response);
    } catch (error) {
      this.sendJson(resArg, 400, {
        accepted: false,
        message: `BaseOS heartbeat failed: ${(error as Error).message}`,
      } satisfies IBaseOsHeartbeatResponse);
    }
  }

  public async handleImageDownloadHttpRequest(
    reqArg: plugins.typedserver.Request,
    resArg: plugins.typedserver.Response,
  ) {
    try {
      const requestUrl = new URL((reqArg as any).originalUrl || reqArg.url || '/', 'http://localhost');
      const buildId = requestUrl.pathname.split('/').at(-2);
      const token = requestUrl.searchParams.get('token');
      if (!buildId || !token) {
        this.sendJson(resArg, 400, { errorText: 'build id or download token missing' });
        return;
      }
      const build = await this.getImageBuildById(buildId);
      if (build.downloadTokenHash !== this.hashSecret(token) || (build.downloadTokenExpiresAt || 0) < Date.now()) {
        this.sendJson(resArg, 403, { errorText: 'download token is invalid or expired' });
        return;
      }
      if (build.data.status !== 'ready' || !build.data.artifact) {
        this.sendJson(resArg, 409, { errorText: 'image build is not ready' });
        return;
      }

      const artifact = build.data.artifact;
      const smartbucket = new plugins.smartbucket.SmartBucket({
        ...this.cloudlyRef.config.data.s3Descriptor,
        port: Number((this.cloudlyRef.config.data.s3Descriptor as any).port || 443),
      } as any);
      const bucket = await smartbucket.getBucketByName(artifact.bucketName);
      const artifactStream = await bucket.fastGetStream({ path: artifact.key }, 'nodestream');
      resArg.status(200);
      resArg.setHeader('Content-Type', artifact.contentType || 'application/octet-stream');
      resArg.setHeader('Content-Length', String(artifact.size));
      resArg.setHeader('Content-Disposition', `attachment; filename="${artifact.filename}"`);
      (artifactStream as nodeStream.Readable).pipe(resArg as any);
    } catch (error) {
      this.sendJson(resArg, 500, {
        errorText: `BaseOS image download failed: ${(error as Error).message}`,
      });
    }
  }

  public async registerNode(
    requestDataArg: IBaseOsRegisterRequest,
  ): Promise<IBaseOsRegisterResponse> {
    if (!this.isRuntimeInfo(requestDataArg.status)) {
      return {
        accepted: false,
        message: 'BaseOS runtime status is missing or invalid',
      };
    }

    if (requestDataArg.nodeToken) {
      const existingNode = await this.getNodeByToken(requestDataArg.nodeToken);
      if (existingNode) {
        await this.updateNodeRuntimeInfo(existingNode, requestDataArg.status, true);
        return {
          accepted: true,
          nodeId: existingNode.id,
        };
      }
    }

    const acceptedBuild = await this.consumeProvisioningToken(requestDataArg.joinToken);
    if (acceptedBuild) {
      const nodeToken = await this.cloudlyRef.authManager.createNewSecureToken();
      const node = await this.upsertNode(requestDataArg.status, nodeToken);
      return {
        accepted: true,
        nodeId: node.id,
        nodeToken,
      };
    }

    const configuredJoinToken = await this.cloudlyRef.settingsManager.getSetting('baseosJoinToken');
    if (!configuredJoinToken) {
      return {
        accepted: false,
        message: 'BaseOS join token is not configured in Cloudly settings',
      };
    }

    if (!requestDataArg.joinToken || requestDataArg.joinToken !== configuredJoinToken) {
      return {
        accepted: false,
        message: 'BaseOS join token is invalid',
      };
    }

    const nodeToken = await this.cloudlyRef.authManager.createNewSecureToken();
    const node = await this.upsertNode(requestDataArg.status, nodeToken);
    return {
      accepted: true,
      nodeId: node.id,
      nodeToken,
    };
  }

  public async acceptHeartbeat(
    requestDataArg: IBaseOsHeartbeatRequest,
  ): Promise<IBaseOsHeartbeatResponse> {
    if (!requestDataArg.nodeToken) {
      return {
        accepted: false,
        message: 'BaseOS node token is missing',
      };
    }
    if (!this.isRuntimeInfo(requestDataArg.status)) {
      return {
        accepted: false,
        message: 'BaseOS runtime status is missing or invalid',
      };
    }

    const node = await this.getNodeByToken(requestDataArg.nodeToken);
    if (!node) {
      return {
        accepted: false,
        message: 'BaseOS node token is invalid',
      };
    }

    await this.updateNodeRuntimeInfo(node, requestDataArg.status, true);
    return {
      accepted: true,
      desiredState: node.data.desiredState || {},
    };
  }

  public async getPublicNodes(): Promise<IBaseOsNodePublic[]> {
    const nodes = await this.CBaseOsNode.getInstances({});
    return nodes.map((nodeArg) => nodeArg.toPublicNode());
  }

  public async createImageBuild(buildRequestArg: IBaseOsImageBuildRequest) {
    const s3Descriptor = this.cloudlyRef.config.data.s3Descriptor;
    if (!s3Descriptor?.bucketName) {
      throw new plugins.typedrequest.TypedResponseError('Cloudly S3 storage is required for BaseOS image builds');
    }

    const workerUrl = await this.cloudlyRef.settingsManager.getSetting('corebuildWorkerUrl');
    const workerToken = await this.cloudlyRef.settingsManager.getSetting('corebuildWorkerToken');
    if (!workerUrl) {
      throw new plugins.typedrequest.TypedResponseError('corebuildWorkerUrl is not configured in Cloudly settings');
    }

    const now = Date.now();
    const buildId = await this.CBaseOsImageBuild.getNewId();
    const provisioningToken = await this.cloudlyRef.authManager.createNewSecureToken();
    const artifactRetentionMs = buildRequestArg.artifactRetentionMs || 1000 * 60 * 60 * 24 * 7;
    const build = new this.CBaseOsImageBuild({
      id: buildId,
      provisioningTokenHash: this.hashSecret(provisioningToken),
      data: {
        status: 'queued',
        architecture: buildRequestArg.architecture,
        cloudlyUrl: buildRequestArg.cloudlyUrl || this.getPublicCloudlyUrl(),
        sourceImageUrl: buildRequestArg.sourceImageUrl,
        ubuntuVersion: buildRequestArg.ubuntuVersion || '24.04',
        hostname: buildRequestArg.hostname,
        wifiSsid: buildRequestArg.wifi?.ssid,
        sshPublicKey: buildRequestArg.sshPublicKey,
        logs: [],
        createdAt: now,
        updatedAt: now,
        expiresAt: now + artifactRetentionMs,
      },
    });
    await build.save();

    this.executeImageBuild(build, provisioningToken, buildRequestArg, workerUrl, workerToken).catch(async (error) => {
      build.data.status = 'failed';
      build.data.errorText = (error as Error).message;
      build.data.updatedAt = Date.now();
      build.data.completedAt = Date.now();
      await build.save();
    });

    return build.toPublicBuild();
  }

  public async getPublicImageBuilds() {
    const builds = await this.CBaseOsImageBuild.getInstances({});
    return builds
      .sort((a, b) => b.data.createdAt - a.data.createdAt)
      .map((buildArg) => buildArg.toPublicBuild());
  }

  public async createImageDownloadUrl(buildIdArg: string) {
    const build = await this.getImageBuildById(buildIdArg);
    if (build.data.status !== 'ready' || !build.data.artifact) {
      throw new plugins.typedrequest.TypedResponseError('BaseOS image build is not ready');
    }
    const token = await this.cloudlyRef.authManager.createNewSecureToken();
    const expiresAt = Date.now() + 1000 * 60 * 15;
    build.downloadTokenHash = this.hashSecret(token);
    build.downloadTokenExpiresAt = expiresAt;
    build.data.updatedAt = Date.now();
    await build.save();
    return {
      url: `/baseos/v1/images/${build.id}/download?token=${encodeURIComponent(token)}`,
      expiresAt,
    };
  }

  private async upsertNode(statusArg: IBaseOsRuntimeInfo, nodeTokenArg: string) {
    const now = Date.now();
    let node = await this.CBaseOsNode.getInstance({
      id: statusArg.nodeId,
    }).catch(() => null);

    if (!node) {
      node = new this.CBaseOsNode({
        id: statusArg.nodeId,
        nodeToken: nodeTokenArg,
        data: {
          runtimeInfo: statusArg,
          createdAt: now,
          updatedAt: now,
          lastHeartbeatAt: now,
        },
      });
    } else {
      node.nodeToken = nodeTokenArg;
      node.data = {
        ...node.data,
        runtimeInfo: statusArg,
        updatedAt: now,
        lastHeartbeatAt: now,
      };
    }

    await node.save();
    return node;
  }

  private async executeImageBuild(
    buildArg: BaseOsImageBuild,
    provisioningTokenArg: string,
    buildRequestArg: IBaseOsImageBuildRequest,
    workerUrlArg: string,
    workerTokenArg?: string,
  ) {
    buildArg.data.status = 'building';
    buildArg.data.startedAt = Date.now();
    buildArg.data.updatedAt = Date.now();
    await buildArg.save();

    const artifactFilename = buildArg.data.architecture === 'amd64'
      ? 'baseos.iso'
      : buildArg.data.architecture === 'arm64'
      ? 'baseos-arm64.iso'
      : 'baseos-rpi.img';
    const artifactKey = `corebuild/baseos/${buildArg.id}/${artifactFilename}`;
    const response = await fetch(
      new URL('/corebuild/v1/jobs/baseos-image', workerUrlArg.endsWith('/') ? workerUrlArg : `${workerUrlArg}/`),
      {
        method: 'POST',
        headers: {
          'content-type': 'application/json',
          ...(workerTokenArg ? { authorization: `Bearer ${workerTokenArg}` } : {}),
        },
        body: JSON.stringify({
          apiToken: workerTokenArg,
          job: {
            id: buildArg.id,
            architecture: buildArg.data.architecture,
            cloudlyUrl: buildArg.data.cloudlyUrl,
            provisioningToken: provisioningTokenArg,
            sourceImageUrl: buildArg.data.sourceImageUrl,
            ubuntuVersion: buildArg.data.ubuntuVersion,
            hostname: buildArg.data.hostname,
            wifi: buildArg.data.wifiSsid
              ? {
                  ssid: buildArg.data.wifiSsid,
                  password: buildRequestArg.wifi?.password,
                }
              : undefined,
            sshPublicKey: buildArg.data.sshPublicKey,
            s3Descriptor: this.cloudlyRef.config.data.s3Descriptor,
            artifactKey,
          },
        }),
      },
    );
    const responseBody = await response.json() as ICoreBuildBaseOsImageResponse;
    buildArg.data.logs = responseBody.logs || [];
    if (!response.ok || !responseBody.success || !responseBody.artifact) {
      buildArg.data.status = 'failed';
      buildArg.data.errorText = responseBody.errorText || `CoreBuild failed with HTTP ${response.status}`;
      buildArg.data.updatedAt = Date.now();
      buildArg.data.completedAt = Date.now();
      await buildArg.save();
      return;
    }

    buildArg.data.status = 'ready';
    buildArg.data.artifact = responseBody.artifact;
    buildArg.data.updatedAt = Date.now();
    buildArg.data.completedAt = Date.now();
    await buildArg.save();
  }

  private async getImageBuildById(buildIdArg: string) {
    const build = await this.CBaseOsImageBuild.getInstance({ id: buildIdArg });
    if (!build) {
      throw new plugins.typedrequest.TypedResponseError(`BaseOS image build ${buildIdArg} not found`);
    }
    return build;
  }

  private async consumeProvisioningToken(joinTokenArg?: string) {
    if (!joinTokenArg) {
      return null;
    }
    const tokenHash = this.hashSecret(joinTokenArg);
    const builds = await this.CBaseOsImageBuild.getInstances({
      provisioningTokenHash: tokenHash,
    });
    const build = builds.find((buildArg) => {
      return !buildArg.provisioningTokenConsumedAt && (!buildArg.data.expiresAt || buildArg.data.expiresAt > Date.now());
    });
    if (!build) {
      return null;
    }
    build.provisioningTokenConsumedAt = Date.now();
    build.data.updatedAt = Date.now();
    await build.save();
    return build;
  }

  private hashSecret(secretArg: string) {
    return crypto.createHash('sha256').update(secretArg).digest('hex');
  }

  private getPublicCloudlyUrl() {
    const sslMode = this.cloudlyRef.config.data.sslMode;
    const protocol = sslMode === 'none' ? 'http' : 'https';
    const port = this.cloudlyRef.config.data.publicPort;
    const includePort = sslMode === 'none' && port && !['80', '443'].includes(port);
    return `${protocol}://${this.cloudlyRef.config.data.publicUrl}${includePort ? `:${port}` : ''}`;
  }

  private async updateNodeRuntimeInfo(
    nodeArg: BaseOsNode,
    statusArg: IBaseOsRuntimeInfo,
    heartbeatArg = false,
  ) {
    nodeArg.data = {
      ...nodeArg.data,
      runtimeInfo: statusArg,
      updatedAt: Date.now(),
      ...(heartbeatArg ? { lastHeartbeatAt: Date.now() } : {}),
    };
    await nodeArg.save();
  }

  private async getNodeByToken(nodeTokenArg: string) {
    const nodes = await this.CBaseOsNode.getInstances({
      nodeToken: nodeTokenArg,
    });
    return nodes[0] || null;
  }

  private isRuntimeInfo(valueArg: unknown): valueArg is IBaseOsRuntimeInfo {
    if (!valueArg || typeof valueArg !== 'object') {
      return false;
    }
    const runtimeInfo = valueArg as Partial<IBaseOsRuntimeInfo>;
    return runtimeInfo.runtime === 'baseos'
      && typeof runtimeInfo.nodeId === 'string'
      && runtimeInfo.nodeId.length > 0
      && typeof runtimeInfo.checkedAt === 'number';
  }

  private async readJsonBody<T>(reqArg: plugins.typedserver.Request): Promise<T> {
    const chunks: Buffer[] = [];
    for await (const chunk of reqArg as any) {
      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
    }
    const bodyString = Buffer.concat(chunks).toString('utf8').trim();
    return bodyString ? JSON.parse(bodyString) as T : {} as T;
  }

  private sendJson(
    resArg: plugins.typedserver.Response,
    statusCodeArg: number,
    bodyArg: object,
  ) {
    resArg.status(statusCodeArg);
    resArg.setHeader('Content-Type', 'application/json');
    resArg.end(JSON.stringify(bodyArg));
  }
}