import { BusinessVertical } from "src/modules/business-verticals/entities/business-verticals.entity"
import { Department } from "src/modules/department/entities/department.entity"
import { Role } from "src/modules/role/entities/role.entity"

import {
  Column,
  Entity,
  PrimaryGeneratedColumn,
  CreateDateColumn,
  UpdateDateColumn,
  DeleteDateColumn,
  ManyToOne,
  JoinColumn,
  OneToMany,
  AfterLoad,
  JoinTable,
  ManyToMany,
} from "typeorm"
import { Address } from "./address.entity"
import { IdProof } from "./id-proof.entity"
import { Auth } from "src/modules/auth/entities/auth.entity"
import { FleetManagement } from "src/modules/fleet-management/entities/fleet-management.entity"
import { TripFleetAssignment } from "src/modules/trips/entities/fleet-trip-management.entity"
import { Customer } from "src/modules/customers/entities/customer.entity"
import { State } from "src/modules/state/entities/state.entity"
import { DriverAvailability } from "src/modules/driver-availability/entities/driver-availability.entity"
import { InspectionFleetReport } from "src/modules/inspection-questions/entities/inspection-fleet-report.entity"
import { IncidentReporting } from "src/modules/incident-reporting/entities/incident-reporting.entity"
import { TripCancellation } from "src/modules/trips/entities/trip-cancellations.entity"
import { Rating } from "src/modules/rating/entities/rating.entity"
import { DriverFleetHistory } from "src/modules/fleet-management/entities/driver-fleet-history.entity"
import { Language } from "./languages.entity"
import { City } from "src/modules/city/entities/city.entity"
import { TripTimelineHistory } from "src/modules/trips/entities/trip-timeline.entity"

@Entity("team_members")
export class TeamMember {
  @PrimaryGeneratedColumn()
  id: number

  @Column({ type: "int", nullable: true })
  role_id: number

  @Column({ type: "int", nullable: true })
  user_id: number

  // @Column({ type: "int", nullable: true })
  // department_id: number[]

  // @Column({ type: "int", nullable: true })
  // business_vertical_id: number[]

  @Column({ type: "int", nullable: true })
  reporting_to_id: number

  @Column({ type: "varchar", nullable: true })
  profile_photo: string

  @Column({ type: "varchar", nullable: true })
  first_name: string

  @Column({ type: "varchar", nullable: true })
  last_name: string

  @Column({ type: "varchar", nullable: true })
  email: string

  @Column({ type: "varchar", length: 15, nullable: true })
  phone_number: string

  @Column({ type: "varchar", length: 5, nullable: true })
  country_code: string

  @Column({ type: "date", nullable: true })
  dob: Date

  @Column({ type: "varchar", nullable: true })
  gender: string

  @Column({ type: "varchar", nullable: true })
  emergency_contact_name: string

  @Column({ type: "varchar", length: 5, nullable: true })
  emergency_contact_code: string

  @Column({ type: "varchar", length: 15, nullable: true })
  emergency_contact_number: string

  @Column({ type: "int", nullable: true })
  working_location: number

  @Column({ type: "int", nullable: true })
  working_city_location: number

  @Column({ type: "date", nullable: true })
  joining_date: Date

  @Column({ type: "varchar", default: "Employee" })
  employment_type: string

  @Column({ type: "varchar", nullable: true, default: "inprogress" })
  status: string

  @Column({ type: "int", default: 1 })
  current_step: number

  @Column({ type: "varchar", default: "draft" })
  form_status: string

  @Column({ type: "varchar", default: "off-duty" })
  duty_status: string

  @Column({ type: "varchar", nullable: true })
  ratings: string

  @DeleteDateColumn()
  deleted_at: Date

  @CreateDateColumn({ type: "timestamp", default: () => "NOW()" })
  created_at: Date

  @UpdateDateColumn({ type: "timestamp", default: () => "NOW()" })
  updated_at: Date

  @ManyToOne(() => Role, (role) => role.team_member, {
    onDelete: "RESTRICT",
  })
  @JoinColumn({ name: "role_id" })
  role: Role

  @ManyToMany(() => Department, (dept) => dept.team_members)
  @JoinTable({
    name: "team_members_departments",
    joinColumn: { name: "team_member_id", referencedColumnName: "id" },
    inverseJoinColumn: { name: "department_id", referencedColumnName: "id" },
  })
  department: Department[]

  @ManyToMany(() => BusinessVertical, (bv) => bv.team_members)
  @JoinTable({
    name: "team_members_business_verticals",
    joinColumn: { name: "team_member_id", referencedColumnName: "id" },
    inverseJoinColumn: {
      name: "business_vertical_id",
      referencedColumnName: "id",
    },
  })
  business_vertical: BusinessVertical[]

  @ManyToMany(() => Language, (lang) => lang.team_members)
  @JoinTable({
    name: "team_members_languages",
    joinColumn: { name: "team_member_id", referencedColumnName: "id" },
    inverseJoinColumn: { name: "language_id", referencedColumnName: "id" },
  })
  languages: Language[]

  @OneToMany(() => Auth, (auth) => auth.team_members)
  users: Auth[]

  @ManyToOne(() => TeamMember, { onDelete: "CASCADE" })
  @JoinColumn({ name: "reporting_to_id" })
  reporting_to: TeamMember

  @OneToMany(() => TeamMember, (teamMember) => teamMember.reporting_to)
  reported_team_members: TeamMember[]

  @OneToMany(() => Address, (address) => address.team_member, {
    cascade: true,
  })
  addresses: Address[]

  @OneToMany(() => IdProof, (idProof) => idProof.team_member, {
    cascade: true,
  })
  id_proofs: IdProof[]

  @OneToMany(() => IdProof, (idProof) => idProof.verifier)
  verified_id_proofs: IdProof[]

  @OneToMany(
    () => FleetManagement,
    (fleetManagement) => fleetManagement.assignedDriver,
    {
      cascade: true,
    },
  )
  vehicles: FleetManagement[]

  @OneToMany(
    () => FleetManagement,
    (trip_driver) => trip_driver.assigned_dispatcher,
  )
  fleetManagement: FleetManagement

  @OneToMany(() => TripFleetAssignment, (trip_driver) => trip_driver.driver)
  trip_driver: TripFleetAssignment

  @OneToMany(() => DriverFleetHistory, (driver) => driver.driver)
  driver_fleet_history: DriverFleetHistory

  @OneToMany(() => Customer, (customer) => customer.dispatcher)
  customer: Customer

  @OneToMany(() => DriverAvailability, (availability) => availability.driver)
  driver_availability: DriverAvailability[]

  @OneToMany(() => InspectionFleetReport, (report) => report.driver)
  driver_inspection_reports: InspectionFleetReport[]

  // @OneToMany(() => InspectionFleetReport, (report) => report.dispatcher)
  // dispatcher_inspection_reports: InspectionFleetReport[]

  @ManyToOne(() => State, (state) => state.team_member)
  @JoinColumn({ name: "working_location" })
  state: State

  @ManyToOne(() => City, (city) => city.team_member)
  @JoinColumn({ name: "working_city_location" })
  city: City

  @OneToMany(
    () => IncidentReporting,
    (incident_reporting) => incident_reporting.team_member,
  )
  incident_reporting: IncidentReporting

  @OneToMany(
    () => TripCancellation,
    (cancellation) => cancellation.cancel_member,
  )
  cancellations: TripCancellation[]

  @OneToMany(() => TripTimelineHistory, (history) => history.changed_by)
  trip_status_changes: TripTimelineHistory[]

  @AfterLoad()
  async profilePict() {
    if (this.profile_photo) {
      this.profile_photo =
        process.env.FILE_UPLOAD === "Local"
          ? `${process.env.BACK_URL}/${this.profile_photo}`
          : `${process.env.CLOUDFLARE_R2_PUBLIC_URL}/${this.profile_photo}`
    }
  }

  @OneToMany(() => Rating, (rating) => rating.rater_driver)
  givenRatings: Rating[]

  @OneToMany(() => Rating, (rating) => rating.rated_driver)
  receivedRatings: Rating[]
}