import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  Query,
  UseGuards,
  Put,
} from "@nestjs/common";
import { OpHubNewBillingService } from "./op-hub-new-billing.service";
import { CreateOpHubNewBillingDto } from "./dto/create-op-hub-new-billing.dto";
import { UpdateOpHubNewBillingDto } from "./dto/update-op-hub-new-billing.dto";
import { makepaymentV3 } from "./entities/op-hub-new-billing.entity";
import { AuthGuard } from "src/auth/auth.guard";
import { DeductDiscountDto } from "./dto/deduct_discount.dto";

@Controller("op-hub-new-billing")
export class OpHubNewBillingController {
  constructor(
    private readonly opHubNewBillingService: OpHubNewBillingService
  ) { }

  @UseGuards(AuthGuard)
  @Get("billing-summary-bills")
  findAll(
    @Query("hospital_id") hospital_id: number,
    @Query("patient_id") patient_id: string,
    @Query("payment_module") payment_module: string,
    @Query("bill_type") bill_type: string,
    @Query("limit") limit: number,
    @Query("page") page: number,
    @Query("searchText") search_text: string,
     @Query('appointment_id') appointment_id: number,

  ) {
    if (!patient_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "Patient ID is required",
      };
    }

    if (bill_type && bill_type !== "due" && bill_type !== "paid") {
      return {
        status: "failed",
        status_code: 400,
        message: "Bill_Type must be due or paid",
      };
    }
    return this.opHubNewBillingService.findAll(
      hospital_id,
      patient_id,
      payment_module,
      bill_type,
      limit || 10,
      page || 1,
      search_text,
      appointment_id
    );
  }

  @UseGuards(AuthGuard)
  @Get("transaction-list")
  async findOne(
    @Query("hospital_id") hospital_id: number,
    @Query("patient_id") patient_id: number,
    @Query("payment_module") payment_module: string,
    @Query("limit") limit: number,
    @Query("page") page: number,
     @Query('appointment_id') appointment_id: number
  ) {
    if (!patient_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "patient_id is required",
      };
    }
    return this.opHubNewBillingService.findtransactiondetails(
      hospital_id,
      patient_id,
      payment_module,
      limit || 10,
      page || 1,
      appointment_id
    );
  }

  @UseGuards(AuthGuard)
  @Post("patient-wallet")
  update(
    @Query("hospital_id") hospital_id: number,
    @Query("patient_id") patient_id: string
  ) {
    return this.opHubNewBillingService.findpatient_wallet(
      hospital_id,
      patient_id
    );
  }

  @UseGuards(AuthGuard)
  @Post("coins-used")
  coins_used(
    @Query("hospital_id") hospital_id: number,
    @Query("patient_id") patient_id: string,
    @Query("coins_used") coins_used: number
  ) {
    if (!patient_id || !coins_used) {
      return {
        status: "failed",
        status_code: 400,
        message: "Patient ID and coins_used is required",
      };
    }
    return this.opHubNewBillingService.coins_used(
      hospital_id,
      patient_id,
      coins_used
    );
  }

  @UseGuards(AuthGuard)
  @Post("/makePayment")
  // @ApiOperation({ summary: 'Make a payment for a patient' })
  // @ApiResponse({
  //   status: 201,
  //   description: 'Payment made successfully.',
  // })
  // @ApiResponse({
  //   status: 404,
  //   description: 'Patient charge not found.',
  // })
  // @ApiResponse({
  //   status: 400,
  //   description: 'Bad request. Validation errors or missing parameters.',
  //   type: ErrorResponse400,
  // })
  // @ApiResponse({
  //   status: 500,
  //   description: 'Internal server error.',
  //   type: ErrorResponse500,
  // })
  makePaymentV3(
    @Query("hospital_id") hospital_id: number,
    @Body() createBillingDto: makepaymentV3
  ) {
    if (
      Number(createBillingDto.amount_from_coins) +
      Number(createBillingDto.actual_amount_paid) !=
      Number(createBillingDto.totalDue)
    ) {
      return {
        status_code: 400,
        status: "failed",
        message:
          "sum of amount_from_coins and actual_amount_paid must be equal to totaldue ",
      };
    }
    if (!createBillingDto.received_by_name) {
      return {
        status_code: process.env.ERROR_STATUS_CODE_PARAMS_MISSING_V2,
        status: process.env.ERROR_STATUS,
        message: process.env.ERROR_STATUS_CODE_PARAMS_MISSING_V2,
      };
    }
    if (!createBillingDto.paymentDetails) {
      return {
        status_code: process.env.ERROR_STATUS_CODE_PARAMS_MISSING_V2,
        status: process.env.ERROR_STATUS,
        message: process.env.ERROR_MESSAGE_PARAM_MISSING,
      };
    }

    if (!createBillingDto.patient_details) {
      return {
        status_code: process.env.ERROR_STATUS_CODE_PARAMS_MISSING_V2,
        status: process.env.ERROR_STATUS,
        message: process.env.ERROR_MESSAGE_PARAM_MISSING,
      };
    }
    if (!createBillingDto.payment_method) {
      return {
        status_code: process.env.ERROR_STATUS_CODE_PARAMS_MISSING_V2,
        status: process.env.ERROR_STATUS,
        message: process.env.ERROR_MESSAGE_PARAM_MISSING,
      };
    }
    if (
      createBillingDto.payment_mode.toLocaleLowerCase() == "card" &&
      !createBillingDto.card_division &&
      !createBillingDto.card_bank_name &&
      !createBillingDto.card_type &&
      !createBillingDto.card_transaction_id
    ) {
      return {
        status_code: process.env.ERROR_STATUS_CODE_PARAMS_MISSING_V2,
        status: process.env.ERROR_STATUS,
        message: process.env.ERROR_MESSAGE_PARAM_MISSING,
      };
    }

    if (
      createBillingDto.payment_mode.toLocaleLowerCase() == "net_banking" &&
      !createBillingDto.net_banking_division &&
      !createBillingDto.net_banking_transaction_id
    ) {
      return {
        status_code: process.env.ERROR_STATUS_CODE_PARAMS_MISSING_V2,
        status: process.env.ERROR_STATUS,
        message: process.env.ERROR_MESSAGE_PARAM_MISSING,
      };
    }
    if (
      createBillingDto.payment_mode.toLocaleLowerCase() == "upi" &&
      !createBillingDto.upi_id &&
      !createBillingDto.upi_transaction_id &&
      !createBillingDto.upi_bank_name
    ) {
      return {
        status_code: process.env.ERROR_STATUS_CODE_PARAMS_MISSING_V2,
        status: process.env.ERROR_STATUS,
        message: process.env.ERROR_MESSAGE_PARAM_MISSING,
      };
    }
    return this.opHubNewBillingService.makepaymentV3(
      hospital_id,
      createBillingDto
    );
  }

  @UseGuards(AuthGuard)
  @Get("get-transaction-details")
  gettransactiondata(
    @Query("hospital_id") hospital_id: number,
    @Query("hos_transaction_id") hos_transaction_id: string
  ) {
    if (!hospital_id || !hos_transaction_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "Hospital ID and Hos_Transaction ID is required",
      };
    }

    return this.opHubNewBillingService.get_transaction_details(
      hospital_id,
      hos_transaction_id
    );
  }

  @UseGuards(AuthGuard)
  @Post("add-in-overallcharge")
  Addchargedata(
    @Query("aayush_unique_id") aayush_unique_id: string,
    @Query("hospital_id") hospital_id: number,
    @Body() body: any
  ) {
    if (!aayush_unique_id || !hospital_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "aayush_unique_id, hospital_id are required",
      };
    }
    if (
      Number(body.total_tax_amount) + Number(body.overall_subtotal_amount) !=
      Number(body.total_billed_amount)
    ) {
      return {
        status: "failed",
        status_code: 400,
        message:
          "sum of subtotal and tax amount must be equal to billed amount",
      };
    }
    return this.opHubNewBillingService.add_overall_charges(
      aayush_unique_id,
      hospital_id,
      body
    );
  }

  @UseGuards(AuthGuard)
  @Post("update-in-overallcharge")
  Updatechargedata(
    @Query("aayush_unique_id") aayush_unique_id: string,
    @Query("hospital_id") hospital_id: number,
    @Body() body: any
  ) {
    if (!aayush_unique_id || !hospital_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "aayush_unique_id, hospital_id are required",
      };
    }

    return this.opHubNewBillingService.update_overall_charges(
      aayush_unique_id,
      hospital_id,
      body
    );
  }

  // @Get('/app')
  // async findApp(
  //   @Query('patient_id') patient_id: number,
  //   @Query('hospital_id') hospital_id: number,
  // ) {
  //   if (!patient_id) {
  //     return {
  //       status: 'failed',
  //       status_code: 400,
  //       message: 'patient_id is required',
  //     };
  //   }

  //   if (!hospital_id) {
  //     return {
  //       status: 'failed',
  //       status_code: 400,
  //       message: 'hospital_id is required',
  //     };
  //   }

  //   return this.newBillingService.finddepartment_id(patient_id, hospital_id);
  // }

  @UseGuards(AuthGuard)
  @Get("dashboard")
  async dashboard(
    @Query("hospital_id") hospital_id: number,
    @Query("limit") limit: number,
    @Query("page") page: number,
    @Query("payment_status") payment_status: string,
    @Query("searchText") searchText: string
  ) {
    console.log(
      payment_status,
      "payment_status",
      payment_status &&
      payment_status !== "paid" &&
      payment_status !== "partially_paid" &&
      payment_status !== "due"
    );

    if (
      payment_status &&
      payment_status !== "paid" &&
      payment_status !== "partially_paid" &&
      payment_status !== "due"
    ) {
      return {
        status: "failed",
        status_code: 400,
        message: "payment_status must be due or paid or partially_paid",
      };
    }
    return this.opHubNewBillingService.overall_dashboard_data(
      hospital_id,
      limit || 10,
      page || 1,
      payment_status,
      searchText
    );
  }

  @UseGuards(AuthGuard)
  @Get("dashboard-mongo-data")
  dashboardtransactiondata(
    @Query("hospital_id") hospital_id: number,
    @Query("limit") limit: number,
    @Query("page") page: number,
    @Query("search") search: string,
    @Query("start_date") start_date: any,
    @Query("end_date") end_date: any
  ) {
    return this.opHubNewBillingService.dashboard_mongo_data(
      hospital_id,
      limit || 10,
      page || 1,
      search,
      start_date,
      end_date
    );
  }

  @UseGuards(AuthGuard)
  @Get("dashboard-count")
  dashboardcount(@Query("hospital_id") hospital_id: number) {
    if (!hospital_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "hospital_id is required",
      };
    }
    return this.opHubNewBillingService.dashboard_count(hospital_id);
  }

  @UseGuards(AuthGuard)
  @Get("patient-balance")
  balance(
    @Query("hospital_id") hospital_id: number,
    @Query("aayush_unique_id") aayush_unique_id: string
  ) {
    if (!aayush_unique_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "aayush_unique_id is required",
      };
    }
    return this.opHubNewBillingService.balance_by_patient(
      hospital_id,
      aayush_unique_id
    );
  }

  @UseGuards(AuthGuard)
  @Get("/department")
  async findApp(
    @Query("patient_id") patient_id: string,
    @Query("hospital_id") hospital_id: number,
    @Query("moduleCode") module: string
  ) {
    if (!patient_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "patient_id is required",
      };
    }

    if (!hospital_id) {
      return {
        status: "failed",
        status_code: 400,
        message: "hospital_id is required",
      };
    }

    return this.opHubNewBillingService.finddepartment_id(
      hospital_id,
      patient_id,
      module
    );
  }

  @Get("/departmentdetails")
  async finddepartmentdetails() {
    return this.opHubNewBillingService.department_details();
  }

  @Delete("delete-charges")
  async delete_additional_charges(
    @Query("patient_charge_id") patient_charge_id: number,
    @Query("opd_id") opd_id: string,
    @Query("ipd_id") ipd_id: string,
    @Query("hospital_id") hospital_id: number
  ) {
    if (!patient_charge_id && (!opd_id || !ipd_id)) {
      return {
        status: "failed",
        status_code: 400,
        message: "patient_charge_id and opd_id/ipd_id are required",
      };
    }
    return this.opHubNewBillingService.delete_charges(
      patient_charge_id,
      opd_id,
      hospital_id,
      ipd_id
    );
  }

  @UseGuards(AuthGuard)
  @Put("discount_update_overall_charges")
  discount_update_overall_charges(@Body() deductDiscountDto: DeductDiscountDto
  ) {
    return this.opHubNewBillingService.discount_update_overall_charges(
      deductDiscountDto
    );
  }
}