const request = require('supertest');
const express = require('express');

// Mock CouchDB service before importing routes
jest.mock('../../services/couchdbService', () => ({
  initialize: jest.fn().mockResolvedValue(true),
  create: jest.fn(),
  getById: jest.fn(),
  find: jest.fn(),
  createDocument: jest.fn(),
  updateDocument: jest.fn(),
  deleteDocument: jest.fn(),
  findByType: jest.fn(),
  findUserById: jest.fn(),
  update: jest.fn(),
}));

const reportsRoutes = require('../../routes/reports');
const Report = require('../../models/Report');
const { createTestUser, createTestStreet, createTestReport } = require('../utils/testHelpers');
const couchdbService = require('../../services/couchdbService');

// Create Express app for testing
const app = express();
app.use(express.json());
app.use('/api/reports', reportsRoutes);

describe('Reports Routes', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });
  describe('GET /api/reports', () => {
    it('should get all reports', async () => {
      const { user } = await createTestUser();
      const street = await createTestStreet(user.id);

      await createTestReport(user.id, street.id, { type: 'pothole' });
      await createTestReport(user.id, street.id, { type: 'litter' });

      const response = await request(app)
        .get('/api/reports')
        .expect(200);

      expect(Array.isArray(response.body)).toBe(true);
      expect(response.body.length).toBe(2);
      expect(response.body[0]).toHaveProperty('type');
      expect(response.body[0]).toHaveProperty('description');
    });

    it('should return empty array when no reports exist', async () => {
      const response = await request(app)
        .get('/api/reports')
        .expect(200);

      expect(Array.isArray(response.body)).toBe(true);
      expect(response.body.length).toBe(0);
    });

    it('should populate street and user data', async () => {
      const { user } = await createTestUser({ name: 'Reporter User' });
      const street = await createTestStreet(user.id, { name: 'Main Street' });
      await createTestReport(user.id, street.id);

      const response = await request(app)
        .get('/api/reports')
        .expect(200);

      expect(response.body[0]).toHaveProperty('street');
      // Populated fields might be objects or strings depending on the route implementation
    });
  });

  describe('POST /api/reports', () => {
    it('should create a new report with authentication', async () => {
      const { user, token } = await createTestUser();
      const street = await createTestStreet(user.id);

      const reportData = {
        street: street.id,
        issue: 'Large pothole on Main Street',
      };

      const response = await request(app)
        .post('/api/reports')
        .set('x-auth-token', token)
        .send(reportData)
        .expect(200);

      expect(response.body).toHaveProperty('_id');
      expect(response.body.issue).toBe(reportData.issue);
      expect(response.body.street.toString()).toBe(street.id);

      // Verify report was created in database
      const report = await Report.findById(response.body._id);
      expect(report).toBeTruthy();
      expect(report.issue).toBe(reportData.issue);
    });

    it('should reject report creation without authentication', async () => {
      const { user } = await createTestUser();
      const street = await createTestStreet(user.id);

      const reportData = {
        street: street.id,
        issue: 'Unauthorized report',
      };

      const response = await request(app)
        .post('/api/reports')
        .send(reportData)
        .expect(401);

      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
    });

    it('should handle missing required fields', async () => {
      const { token } = await createTestUser();

      const response = await request(app)
        .post('/api/reports')
        .set('x-auth-token', token)
        .send({ issue: 'Incomplete report' })
        .expect(500);

      expect(response.body).toBeDefined();
    });
  });

  describe('PUT /api/reports/:id', () => {
    it('should resolve a report with authentication', async () => {
      const { user, token } = await createTestUser();
      const street = await createTestStreet(user.id);
      const report = await createTestReport(user.id, street.id, {
        status: 'pending'
      });

      const response = await request(app)
        .put(`/api/reports/${report.id}`)
        .set('x-auth-token', token)
        .expect(200);

      expect(response.body).toHaveProperty('status', 'resolved');

      // Verify report was updated in database
      const updatedReport = await Report.findById(report.id);
      expect(updatedReport.status).toBe('resolved');
    });

    it('should return 404 for non-existent report', async () => {
      const { token } = await createTestUser();
      const fakeId = '507f1f77bcf86cd799439011';

      const response = await request(app)
        .put(`/api/reports/${fakeId}`)
        .set('x-auth-token', token)
        .expect(404);

      expect(response.body).toHaveProperty('msg', 'Report not found');
    });

    it('should reject resolution without authentication', async () => {
      const { user } = await createTestUser();
      const street = await createTestStreet(user.id);
      const report = await createTestReport(user.id, street.id);

      const response = await request(app)
        .put(`/api/reports/${report.id}`)
        .expect(401);

      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
    });

    it('should handle invalid report ID format', async () => {
      const { token } = await createTestUser();

      const response = await request(app)
        .put('/api/reports/invalid-id')
        .set('x-auth-token', token)
        .expect(500);

      expect(response.body).toBeDefined();
    });

    it('should allow resolving already resolved reports', async () => {
      const { user, token } = await createTestUser();
      const street = await createTestStreet(user.id);
      const report = await createTestReport(user.id, street.id, {
        status: 'resolved'
      });

      const response = await request(app)
        .put(`/api/reports/${report.id}`)
        .set('x-auth-token', token)
        .expect(200);

      expect(response.body).toHaveProperty('status', 'resolved');
    });
  });
});