import { Test, TestingModule } from '@nestjs/testing';
import { SisterDetailService } from './sister-detail.service';
import { SshService } from './ssh.service';
import { PrismaService } from '../prisma/prisma.service';
import { ConfigService } from '@nestjs/config';
import { NotFoundException } from '@nestjs/common';

describe('SisterDetailService', () => {
  let service: SisterDetailService;

  const mockSister = {
    id: 2,
    name: 'narang',
    ip: '10.10.10.216',
    user: 'narang',
    lxcId: 105,
    status: 'online',
    lastSeen: new Date(),
    sshKeyPath: null,
    createdAt: new Date(),
    updatedAt: new Date(),
  };

  const mockPrisma = {
    sisterConfig: {
      findUnique: jest.fn(),
      findMany: jest.fn().mockResolvedValue([mockSister]),
    },
    activityLog: {
      findMany: jest.fn().mockResolvedValue([]),
      count: jest.fn().mockResolvedValue(0),
    },
  };

  const mockSsh = { executeCommand: jest.fn() };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        SisterDetailService,
        { provide: SshService, useValue: mockSsh },
        { provide: PrismaService, useValue: mockPrisma },
        {
          provide: ConfigService,
          useValue: {
            get: jest.fn().mockReturnValue('/home/narang/.ssh/id_rsa'),
          },
        },
      ],
    }).compile();

    service = module.get<SisterDetailService>(SisterDetailService);
    jest.clearAllMocks();
  });

  it('getSisterConfig: SSH 실패 시 fallback 반환', async () => {
    mockPrisma.sisterConfig.findUnique.mockResolvedValue(mockSister);
    mockSsh.executeCommand.mockRejectedValue(new Error('timeout'));

    const result = await service.getSisterConfig('narang');

    expect(result.name).toBe('narang');
    expect(result.role).toBe('Generator');
    expect(result.raw).toContain('SSH 연결 불가');
  });

  it('getSisterConfig: sister 없으면 NotFoundException', async () => {
    mockPrisma.sisterConfig.findUnique.mockResolvedValue(null);

    await expect(service.getSisterConfig('narang')).rejects.toThrow(
      NotFoundException,
    );
  });

  it('getSisterSessions: SSH 실패 시 빈 배열', async () => {
    mockPrisma.sisterConfig.findUnique.mockResolvedValue(mockSister);
    mockSsh.executeCommand.mockRejectedValue(new Error('timeout'));

    const result = await service.getSisterSessions('narang');
    expect(result).toEqual([]);
  });

  it('getOrgData: 파이프라인 포함 조직도 반환', async () => {
    const result = await service.getOrgData();

    expect(result.owner.name).toBe('자기야');
    expect(result.sisters).toHaveLength(1);
    expect(result.pipeline.length).toBeGreaterThan(0);
  });

  it('getSisterActivityLog: sisterId 필터 적용', async () => {
    mockPrisma.sisterConfig.findUnique.mockResolvedValue(mockSister);
    mockPrisma.activityLog.findMany.mockResolvedValue([]);

    await service.getSisterActivityLog('narang');

    expect(mockPrisma.activityLog.findMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { sisterId: mockSister.id } }),
    );
  });
});