import { Injectable, HttpException, HttpStatus } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Campaign } from 'src/entities/campaign.entity';
import { responseMessages } from 'src/messages/response-messages';
import { Users } from 'src/entities/users.entity';
import { CampaignInfluencer } from 'src/entities/campaign_influencer.entity';
import { Draft } from 'src/entities/draft.entity';
import { DraftVersions } from 'src/entities/draft_versions.entity';
import { DraftComments } from 'src/entities/draft_comments.entity';
import { from } from 'rxjs';
import { Posts } from 'src/entities/posts.entity';
import { SocialMedias } from 'src/entities/social-medias.entity';
import axios from 'axios';
import { query } from 'express';
import { SocketGateway } from 'src/common/services/socket/socket.gateway';
import { DispuetStatus, Dispute } from 'src/entities/dispute.entity';
import slugify from 'slugify';
import { DisputeHistory } from 'src/entities/dispute-history.entity';

@Injectable()
export class DisputeRepository {
    constructor(
        private SocketGateway: SocketGateway,

        @InjectRepository(Campaign)
        private Campaign: Repository<Campaign>,

        @InjectRepository(Users)
        private Users: Repository<Users>,

        @InjectRepository(CampaignInfluencer)
        private CampaignInfluencer: Repository<CampaignInfluencer>,

        @InjectRepository(Dispute)
        private Dispute: Repository<Dispute>,

        @InjectRepository(DisputeHistory)
        private DisputeHistory: Repository<DisputeHistory>,

        @InjectRepository(DraftComments)
        private DraftComments: Repository<DraftComments>,

        @InjectRepository(Posts)
        private Posts: Repository<Posts>,

        @InjectRepository(SocialMedias)
        private SocialMedias: Repository<SocialMedias>,
    ) { }


    async create(request: any, camapignInfluencer: any, user: any, campaign: any) {
        let dispute = await this.Dispute.findOne({ where: { campaign_influencer: { id: camapignInfluencer.id } } });
        if (!dispute) {
            dispute = new Dispute();
            dispute.campaign_influencer = camapignInfluencer;
            dispute.slug = await this.generateSlug(campaign.campaign_name);
            dispute.campaign = campaign;
            dispute.status = DispuetStatus.UNSOLVED;
            dispute.brand = campaign.users;
            dispute.influencer = camapignInfluencer.influencer;
        }
        if (user.role == 'brand') {
            dispute.is_brand_despute = true;
        }
        if (user.role == 'influencer') {
            dispute.is_influencer_despute = true;
        }
        dispute.status = DispuetStatus.UNSOLVED;
        dispute.winner = null;
        dispute.message = "";
        dispute = await this.Dispute.save(dispute);
        if (dispute) {
            let disputeHistory = {
                dispute_by: user,
                dispute: dispute,
                reason: request.reason,
                description: request.description,
                attachment: request.attachment
            }
            await this.DisputeHistory.save(disputeHistory);
        }
        return;
    }

    async generateSlug(campaign_name) {
        // Generate initial slug from the name
        let slug = campaign_name.trim()
            .toLowerCase()
            .replace(/[\/\\?%*:|"<>&]+/g, '') // remove special characters
            .replace(/\s+/g, '-')             // replace spaces with dashes
            .replace(/-+/g, '-');
        //   let slug = slugify(`${campaign_name}`, { lower: true, strict: true })

        // Check if the slug exists
        let existing = await this.Dispute.findOne({ where: { slug } })

        // If slug exists, append a 4-character random string
        if (existing) {
            const randomString = Math.random().toString(36).substring(2, 6) // Generate a 4-character random string
            slug = `${slug}_${randomString}`
        }
        return slug
    }

    async commonQuery() {
        return await this.Dispute.createQueryBuilder('dispute')
            .leftJoin('dispute.campaign_influencer', 'campaign_influencer').withDeleted()
            .leftJoin('dispute.brand', 'brand')
            .leftJoin('dispute.influencer', 'influencer')
            .leftJoin('dispute.campaign', 'campaign')
            .select(["dispute", "campaign_influencer",
                "campaign.id",
                "campaign.campaign_name",
                "campaign.slug",
                "campaign.currency",
                "campaign.budget_per_influencer",
                "campaign.number_of_influencers",
                "campaign.total_budget",
                "campaign.content_type",
                "campaign.influencer_type",
                "campaign.job_requirement",
                "campaign.posting_start_date",
                "campaign.posting_end_date",
                "campaign.first_draft_date",
                "campaign.campaign_image",
                "campaign.profile_privacy",
                "campaign.status",
                "campaign.campaign_requirements",
                "campaign.attachment",
                "campaign.messages",
                "campaign.invited",
                "campaign.hired",
                "campaign.created_at",
                "brand.id", "brand.slug", "brand.first_name", "brand.last_name", "brand.email", "brand.image", "brand.country",
                "influencer.id",
                "influencer.slug",
                "influencer.first_name",
                "influencer.last_name",
                "influencer.image",
                "influencer.total_followers",
                "influencer.country",
                "influencer.platforms",
                "influencer.engagement_ratio",
                "influencer.display_name"
            ])
    }
}