import {
  Controller,
  Get,
  ServiceUnavailableException,
  Request,
  Inject,
  UseGuards,
  Post,
  Put,
  Delete,
  Param,
  Body,
  UseInterceptors,
  UnauthorizedException,
} from "@nestjs/common";
import { AuthRequest, EndUserRoles } from "src/common/interfaces";
import { ProfileService } from "./profile.service";
import { AuthGuard } from "@nestjs/passport";
import { RolesAuthGuard } from "src/auth/guards/roles-auth.guard";
import { UpdateModuleDto } from "src/module-manager/dto/update-module.dto";
import { RestrictInvestorDto } from "./dto/restirct-investor.dto";
import { DynamicFieldsDto } from "./dto/dynamicfields-investor.dto";
import { InvestorSanctionDto } from "./dto/investor-sanction.dto";
import { CreateRoleDto } from "./dto/create-role.dto";
import { GrantRoleDto } from "./dto/grant-role.dto";
import { ManageRoleAccessDto } from "./dto/manage-role.dto";
import { ResetRoleDto } from "./dto/reset-role.dto";
import { encodeBytes32String, hexlify, keccak256, toUtf8Bytes } from "ethers";
import { OnChainDataField } from "src/shared/onchainDataFields/entities/onChainDataField.entity";
import { ModuleDto } from "src/module-manager/dto/module.dto";
import { UserService } from "src/user/user.service";
import { CustomCacheInterceptor } from "src/interceptor/cache.interceptor";
import { SummaryService } from "./summary.service";

@Controller("api/v1/profile")
export class ProfileController {
  @Inject(ProfileService)
  private readonly profileService: ProfileService;
  @Inject(UserService)
  private readonly userService: UserService;

  @Inject(SummaryService)
  private readonly summaryService: SummaryService;

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(AuthGuard("jwt"))
  @Get("/")
  async getProfile(@Request() request: AuthRequest) {
    try {
      return await this.profileService.getMyProfile(request.user);
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(AuthGuard("jwt"))
  @Post("/registries/:id/dynamic-fields/")
  async setForAllUsers(
    @Request() request: AuthRequest,
    @Param("id") id: string,
    @Body() dynamicFieldsDto: DynamicFieldsDto,
  ) {
    try {
      const idInBytes = encodeBytes32String(id);
      const onchainFields: OnChainDataField[] = [];

      const registriesWithId = dynamicFieldsDto.registries.map((registry) => {
        onchainFields.push({
          name: registry.dataFieldName,
          hash: keccak256(hexlify(toUtf8Bytes(registry.dataFieldName))),
          linkedName: "",
          linkedHash: "",
          linkedType: "",
        });
        return { ...registry, id: idInBytes };
      });
      return await this.userService.setRegistryData({
        ...dynamicFieldsDto,
        registries: registriesWithId,
        userJwtPayload: request.user,
        onchainFields,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(new RolesAuthGuard(["dealer", "investor"]))
  @Get("/summary")
  async summary(@Request() request: AuthRequest) {
    try {
      if (request.user.role === EndUserRoles.dealer) {
        return await this.summaryService.getDealerSummary(request.user);
      }
      return await this.summaryService.getInvestorSummary(request.user);
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["dealer", "fundAdmin"]))
  @Post("/module/register")
  async registerModule(
    @Request() request: AuthRequest,
    @Body() moduleDto: ModuleDto,
  ) {
    try {
      return await this.profileService.userRegisterModule({
        userJwtPayload: request.user,
        contractAddress: moduleDto.contractAddress,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["dealer", "fundAdmin"]))
  @Put("/module/update")
  async updateModule(
    @Request() request: AuthRequest,
    updateModuleDto: UpdateModuleDto,
  ) {
    try {
      return await this.profileService.userEnableDisableModule({
        userJwtPayload: request.user,
        contractAddress: updateModuleDto.contractAddress,
        status: updateModuleDto.status,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["dealer", "fundAdmin"]))
  @Delete("/module/delete")
  async deleteModule(@Request() request: AuthRequest, ModuleDto: ModuleDto) {
    try {
      return await this.profileService.userDeleteModule({
        userJwtPayload: request.user,
        contractAddress: ModuleDto.contractAddress,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseInterceptors(CustomCacheInterceptor)
  @UseGuards(new RolesAuthGuard(["dealer", "investor"]))
  @Get("/investor/:id/verify/:instrumentId")
  async allowInvestor(
    @Request() request: AuthRequest,
    @Param("id") id: string,
    @Param("instrumentId") instrumentId: string,
  ) {
    try {
      if (request.user.role === EndUserRoles.investor) {
        const investor = await this.userService.findUserByProperty({
          email: request.user.email,
        });
        if (investor._id.toString() !== id) {
          throw new UnauthorizedException(
            "Investor can check his avilablilty only",
          );
        }
      }
      return await this.profileService.verifyInvestor({
        investorId: id,
        instrumentId,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["admin", "dealer"]))
  @Post("/investor/:id/sanction")
  async setSanction(
    @Request() request: AuthRequest,
    @Param("id") id: string,
    @Body() investorSanctionDto: InvestorSanctionDto,
  ) {
    try {
      return await this.profileService.setSanction({
        userJwtPayload: request.user,
        investorId: id,
        investorSanction: investorSanctionDto,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(new RolesAuthGuard(["dealer"]))
  @Post("/investor/:id/restrict")
  async restrictInvestor(
    @Request() request: AuthRequest,
    @Param("id") id: string,
    @Body() restrictInvestorDto: RestrictInvestorDto,
  ) {
    try {
      return await this.profileService.setInvestorRestriction({
        userJwtPayload: request.user,
        investorId: id,
        ...restrictInvestorDto,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(AuthGuard("jwt"))
  @Post("/role/create")
  async createRole(
    @Request() request: AuthRequest,
    @Body() createRole: CreateRoleDto,
  ) {
    try {
      return await this.profileService.createRole({
        ...createRole,
        user: request.user,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(AuthGuard("jwt"))
  @Post("/role/grant")
  async grantRole(
    @Request() request: AuthRequest,
    @Body() createRole: GrantRoleDto,
  ) {
    try {
      return await this.profileService.grantRole({
        ...createRole,
        user: request.user,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }
  @UseGuards(AuthGuard("jwt"))
  @Post("/role/grant/access")
  async grantAccess(
    @Request() request: AuthRequest,
    @Body() manageRoleDto: ManageRoleAccessDto,
  ) {
    try {
      return await this.profileService.manageRoleAccess("grant", {
        ...manageRoleDto,
        user: request.user,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(AuthGuard("jwt"))
  @Post("/role/revoke")
  async revokeRole(
    @Request() request: AuthRequest,
    @Body() manageRoleDto: ManageRoleAccessDto,
  ) {
    try {
      return await this.profileService.manageRoleAccess("revoke", {
        ...manageRoleDto,
        user: request.user,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }

  @UseGuards(AuthGuard("jwt"))
  @Post("/role/reset")
  async resetRole(
    @Request() request: AuthRequest,
    @Body() resetRoleDto: ResetRoleDto,
  ) {
    try {
      return await this.profileService.resetAccess({
        ...resetRoleDto,
        user: request.user,
      });
    } catch (error) {
      console.error(error);
      throw new ServiceUnavailableException(error);
    }
  }
}