import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, DeleteDateColumn, ManyToOne, JoinColumn, OneToMany, Index } from "typeorm"
import { Users } from "./users.entity"
import { CampaignInfluencer } from "./campaign_influencer.entity"
import { CampaignInfluencerBookmarks } from "./campaign_influencer_bookmark.entity"
import { Expose } from "class-transformer"
import { Draft } from "./draft.entity"
import { InfluenceSaveCampaigns } from "./influencer-save-campaigns.entity"
import { CampaignCategory } from "./campaign-caregories.entity"
import { CampaignRecommended } from "./campaign_recommended.entity"
import { InfluencerCampaignRecommended } from "./influencer_campaign_recommended.entity"
import { CampaignAiReport } from "./campaign-ai-report.entity"
const moment = require('moment');

export enum ProfilePrivacy {
    PUBLIC = "public",
    PRIVATE = "private"
}

export enum CampaignStatus {
    COMPLETED = "completed",
    DRAFT = "draft",
    PENDING = "pending",
    PUBLISHED = "published",
    RUNNING = "running"
}

export enum JobPrivacy {
    IN_PERSON = "in_person",
    REMOTE = "remote"
}

@Entity("campaigns")
export class Campaign {
    @PrimaryGeneratedColumn("uuid")
    id: string

    @Index()
    @Column({ name: "campaign_name", type: "varchar", length: 255 })
    campaign_name: string

    @ManyToOne(() => Users, (user) => user.id, { nullable: true })
    @JoinColumn({ name: "users" })
    users: Users

    @Column({ name: "budget_per_influencer", type: "decimal", precision: 10, scale: 2 })
    budget_per_influencer: number

    @Column({ name: "number_of_influencers", type: "int" })
    number_of_influencers: number

    @Column({ name: "total_budget", type: "decimal", precision: 10, scale: 2, default: 0.00 })
    total_budget: number

    @Column({ name: "budget_per_influencer_usd", type: "decimal", precision: 10, scale: 2, default: 0.00 })
    budget_per_influencer_usd: number

    @Column({ name: "total_budget_usd", type: "decimal", precision: 10, scale: 2, default: 0.00 })
    total_budget_usd: number

    @Column({ type: 'jsonb', nullable: true })
    content_type: Record<string, any>;

    @Index()
    @Column({ type: "varchar", length: 255 })
    slug: string

    @Column({ type: "varchar", length: 255 })
    currency: string

    @Column({ name: "influencer_type", type: 'jsonb', nullable: true })
    influencer_type: Record<string, any>;

    @Index()
    @Column({ type: 'jsonb', nullable: true })
    platforms: Record<string, any>;

    @Column({ type: 'jsonb', nullable: true })
    job_requirement: Record<string, any>;

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

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

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

    @Column({ name: "campaign_image", type: "varchar", length: 255, nullable: true })
    campaign_image: string

    @Index()
    @Column({ name: "campaign_country", type: "varchar", length: 255, nullable: true })
    campaign_country: string

    @Column({
        name: "profile_privacy",
        type: "enum",
        enum: ProfilePrivacy,
        default: ProfilePrivacy.PUBLIC
    })
    profile_privacy: string

    @Column({
        name: "status",
        type: "enum",
        enum: CampaignStatus,
        default: CampaignStatus.PENDING
    })
    status: string


    @Column({
        name: "job_privacy",
        type: "enum",
        enum: JobPrivacy,
        default: JobPrivacy.IN_PERSON
    })
    job_privacy: string

    @Column({ name: "campaign_requirements", type: "text", nullable: true })
    campaign_requirements: string

    @Column({ type: 'jsonb', nullable: true })
    attachment: Record<string, any>;

    @Column({ type: "int", default: 0 })
    messages: number

    @Column({ type: "int", default: 0 })
    invited: number

    @Column({ type: "int", default: 0 })
    hired: number

    @Column({ type: "int", default: 0 })
    applied: number

    @Column({ type: 'timestamp', nullable: true })
    recommended_date_time: Date;

    @Column({ type: 'varchar', default: "false", length: 10, })
    is_barter: string

    @Column({ name: "product_value", type: "decimal", precision: 10, scale: 2, default: 0.00 })
    product_value: number

    @Column({ type: 'boolean', default: true })
    is_active: boolean

    @Column({ type: 'boolean', default: false })
    is_open_to_international_influencer: boolean

    @Column({ type: 'boolean', default: false })
    is_only_international_influencer: boolean

    @Column({ type: "timestamp", nullable: true })
    notification_reminder_at: Date

    @Column({ type: "date", default: () => 'CURRENT_DATE' })
    post_sync_cron_at: Date

    @Column({ type: 'jsonb', nullable: true })
    ai_criteria: Record<string, string[]>;

    @Column({ type: 'boolean', default: false })
    ai_report_inprogress: boolean;

    @Expose()
    influencerCount: string

    @OneToMany(() => CampaignInfluencer, (campaignInfluencer) => campaignInfluencer.campaign, { cascade: true })
    campaignInfluencers: CampaignInfluencer[]

    @OneToMany(() => CampaignInfluencerBookmarks, (campaignInfluencer) => campaignInfluencer.campaign, { cascade: true })
    campaignBookmarks: CampaignInfluencerBookmarks[]

    @OneToMany(() => Draft, (drafts) => drafts.campaign, { cascade: true })
    drafts: Draft[]

    @OneToMany(() => InfluenceSaveCampaigns, (campaignInfluencer) => campaignInfluencer.campaign, { cascade: true })
    influencerSaveCampaigns: InfluenceSaveCampaigns[]

    @OneToMany(() => CampaignCategory, (campaign) => campaign.campaign, { cascade: true })
    campaignCategory: CampaignCategory[]

    @OneToMany(() => CampaignRecommended, (recommended) => recommended.campaign, { cascade: true })
    campaignRecommended: CampaignRecommended[]

    @OneToMany(() => InfluencerCampaignRecommended, (recommended) => recommended.campaign, { cascade: true })
    influencerCampaignRecommended: InfluencerCampaignRecommended[]

    @OneToMany(() => CampaignAiReport, (campaignAiReport) => campaignAiReport.campaign, { cascade: true })
    campaignAiReports: CampaignAiReport[]

    @Expose()
    isCampaignSaved: string;

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

    @UpdateDateColumn({
        type: "timestamp",
        precision: 0,
        default: () => "CURRENT_TIMESTAMP",
        onUpdate: "CURRENT_TIMESTAMP"
    })
    updated_at: Date

    @DeleteDateColumn({ type: "timestamp", nullable: true, precision: 0 })
    deleted_at: Date
}