import { Injectable, Logger } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { SocialMediaPlatformEnum } from 'common/enum/social-media-platform.enum';
import { Repository } from 'typeorm';
import { ScheduledPostEntity } from './entities/scheduled-post.entity';
import { FacebookProvider } from './providers/facebook.provider';
import { LinkedinProvider } from './providers/linkedin.provider';

interface ScheduledPost {
  alertId: string;
  platform: SocialMediaPlatformEnum;
  content: string;
  imageUrl: string;
  scheduledTime: Date;
  status: 'pending' | 'published' | 'failed';
  error?: string;
  createdAt: Date;
}


@Injectable()
export class SocialMediaService {
  private readonly logger = new Logger(SocialMediaService.name);

  constructor(
    @InjectRepository(ScheduledPostEntity)
    private facebookProvider: FacebookProvider,
    // private instagramProvider: InstagramProvider,
    private linkedinProvider: LinkedinProvider,
  ) {}

  async schedulePostsForAllPlatforms(): Promise<void> {}

  async schedulePost(): Promise<any> {}
  async publishPost(post: ScheduledPost): Promise<void> {

    try {
      let postId: string;
      switch (post.platform) {
        case SocialMediaPlatformEnum.FACEBOOK:
          postId = await this.facebookProvider.publishPost(post.content, post.imageUrl);
          break;
        // case SocialMediaPlatformEnum.INSTAGRAM:
        //   postId = await this.instagramProvider.publishPost(post.content, post.imageUrl);
        //   break;
        case SocialMediaPlatformEnum.LINKEDIN:
          postId = await this.linkedinProvider.publishPost(post.content, post.imageUrl);
          break;
        default:
          throw new Error(`Unsupported platform: ${post.platform}`);
      }

      this.logger.log(`Post published successfully: ${postId}`);
    } catch (error) {
      this.logger.error(`Failed to publish post: ${error.message}`, error.stack);
      throw error;
    }
  }

  async verifyLinkedin(): Promise<any> {
    try {
      const response = await this.linkedinProvider.verifyAccessToken();
      return response;
    } catch (error) {
      this.logger.error(`LinkedIn verification failed: ${error.message}`, error.stack);
      throw error;
    }
  }
}