import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  Post,
  Patch,
  Query,
  UsePipes,
  ValidationPipe,
  Request,
  UnauthorizedException,
  UseInterceptors,
} from "@nestjs/common";
import { ModelService } from "./model.service";
import { ApiBearerAuth, ApiOkResponse } from "@nestjs/swagger";
import { Model } from "./entities/model.entity";
import {
  RegisterModelDto,
  RegisterModelRequestDto,
} from "./dto/register-model.dto";
import { EditModelDto } from "./dto/edit-model.dto";
import { PolicyService } from "../iam";
import {
  MODEL_CREATE_ACTION,
  MODEL_DELETE_ACTION,
  MODEL_PUSH_METRICS_ACTION,
  MODEL_READ_ACTION,
  MODEL_RESOURCE_NAME,
  MODEL_UPDATE_ACTION,
} from "./model.constants";
import { OpentelemetryProvider } from "../providers/opentelemetry/opentelemetry.provider";
import { ProtobufInterceptor } from "../common/interceptors/protobuf.interceptor";
import { PROJECT_CREATE_KEY_ACTION, PROJECT_RESOURCE_NAME } from "../project/project.constants";

const validationPipe = new ValidationPipe({
  whitelist: true,
  forbidNonWhitelisted: true,
});

@ApiBearerAuth("access-token")
@Controller("model")
export class ModelController {
  constructor(
    private readonly modelService: ModelService,
    private readonly policyService: PolicyService,
  ) {}

  @Post("/:id/metrics")
  @UseInterceptors(
    new ProtobufInterceptor(
      OpentelemetryProvider.METRICS_PROTO_PATH,
      OpentelemetryProvider.METRICS_PROTO_MESSAGE_NAME,
    ),
  )
  async pushMetrics(@Body() metrics, @Param("id") modelId, @Request() request) {
    const model = await this.modelService.findOne(+modelId);
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        model.projectID,
        MODEL_RESOURCE_NAME,
        MODEL_PUSH_METRICS_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    console.log("Metrics received for model: ", modelId);
    console.log("Request headers: ", request.headers);
    console.log(JSON.stringify(metrics, null, 2));

    return this.modelService.pushMetrics(metrics, modelId);
  }

  @Post()
  @ApiOkResponse({ type: Model })
  @UsePipes(validationPipe)
  async registerModel(
    @Body() registerModelInput: RegisterModelDto,
    @Request() request,
  ) {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        registerModelInput.projectID,
        MODEL_RESOURCE_NAME,
        MODEL_CREATE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.modelService.registerModel(registerModelInput);
  }

  @Get()
  @ApiOkResponse({ type: Model, isArray: true })
  @UsePipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
  async findAll(@Request() request): Promise<Model[]> {
    const models = await this.modelService.findAll();

    return models.filter((model) => {
      const canRead = this.policyService.checkPermission(
        request.user.permission,
        model.projectID,
        MODEL_RESOURCE_NAME,
        MODEL_READ_ACTION,
      );
      return canRead;
    });
  }

  @Get(":id")
  @ApiOkResponse({ type: Model })
  @UsePipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
  async findOne(@Param("id") id: string, @Request() request): Promise<Model> {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        id,
        MODEL_RESOURCE_NAME,
        MODEL_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.modelService.findOne(+id);
  }

  @Delete(":id")
  @ApiOkResponse({ type: Model })
  async remove(@Param("id") id: string, @Request() request) {
    const model = await this.modelService.findOne(+id);
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        model.projectID,
        MODEL_RESOURCE_NAME,
        MODEL_DELETE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.modelService.deleteModel(+id);
  }

  @Get("/project/:projectId/list")
  async findForProject(@Param("projectId") projectId, @Request() request) {
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        projectId,
        MODEL_RESOURCE_NAME,
        MODEL_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    const models = await this.modelService.findForProject(+projectId);
    return models.map((model) => {
      const [canUpdate, canDelete, canRequestKey] = [
        this.policyService.checkPermission(
          request.user.permission,
          model.projectID,
          MODEL_RESOURCE_NAME,
          MODEL_UPDATE_ACTION,
        ),
        this.policyService.checkPermission(
          request.user.permission,
          model.projectID,
          MODEL_RESOURCE_NAME,
          MODEL_DELETE_ACTION,
        ),
        this.policyService.checkPermission(
          request.user.permission,
          model.projectID,
          PROJECT_RESOURCE_NAME,
          PROJECT_CREATE_KEY_ACTION,
        ),
      ];

      return { ...model, update: canUpdate, delete: canDelete, canRequestKey: canRequestKey };
    });
  }

  @Get("/:projectId/endpoints/hasCreatePermission")
  canRegisterModelEndpoints(
    @Param("projectId") projectId: number,
    @Request() request,
  ) {
    return this.policyService.checkPermission(
      request.user.permission,
      projectId,
      MODEL_RESOURCE_NAME,
      MODEL_CREATE_ACTION,
    );
  }

  @Get("get-model-info/:id")
  async getModelInfo(@Param("id") id: number, @Request() request) {
    const model = await this.modelService.findOne(+id);
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        model.projectID,
        MODEL_RESOURCE_NAME,
        MODEL_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }
    return this.modelService.getModelInfo(id);
  }

  @Get("fetch-metrics/:id")
  async fetchModelMetrics(
    @Param("id") id: number,
    @Query() query,
    @Request() request,
  ) {
    const model = await this.modelService.findOne(+id);
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        model.projectID,
        MODEL_RESOURCE_NAME,
        MODEL_READ_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    const endTime = new Date();
    const startTime = new Date(new Date().setDate(endTime.getDate() - 1));

    const queryOptions = {
      startTime: startTime.getTime(),
      endTime: endTime.getTime(),
    };

    if ("startTime" in query) {
      queryOptions["startTime"] = +query["startTime"];
    }
    if ("endTime" in query) {
      queryOptions["endTime"] = +query["endTime"];
    }

    return this.modelService.fetchModelMetricsFromStore(id, queryOptions);
  }

  @Patch(":id")
  @ApiOkResponse({ type: Model })
  async updateModel(
    @Param("id") id: string,
    @Request() request,
    @Body() body: EditModelDto,
  ) {
    const model = await this.modelService.findOne(+id);
    if (
      !(await this.policyService.checkPermission(
        request.user.permission,
        model.projectID,
        MODEL_RESOURCE_NAME,
        MODEL_UPDATE_ACTION,
      ))
    ) {
      throw new UnauthorizedException();
    }

    return this.modelService.updateModelName(+id, body);
  }

  @Post("registration-request")
  @ApiOkResponse({ type: Boolean })
  @UsePipes(validationPipe)
  async requestModelRegistration(
    @Body() registerModelInput: RegisterModelRequestDto,
  ) {
    return this.modelService.requestModelRegistration(registerModelInput);
  }
}