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 taskRoutes = require('../../routes/tasks');
const { createTestUser, createTestStreet, createTestTask } = require('../utils/testHelpers');
const couchdbService = require('../../services/couchdbService');

const app = express();
app.use(express.json());
app.use('/api/tasks', taskRoutes);

describe('Task Routes', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });
  describe('GET /api/tasks', () => {
    it('should get all tasks completed by authenticated user', async () => {
      const { user, token } = await createTestUser();
      const street = await createTestStreet(user.id);

      await createTestTask(user.id, street.id, {
        completedBy: user.id,
        status: 'completed'
      });
      await createTestTask(user.id, street.id, {
        completedBy: user.id,
        status: 'completed'
      });

      const response = await request(app)
        .get('/api/tasks')
        .set('x-auth-token', token)
        .expect(200);

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

    it('should return empty array when user has no completed tasks', async () => {
      const { token } = await createTestUser();

      const response = await request(app)
        .get('/api/tasks')
        .set('x-auth-token', token)
        .expect(200);

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

    it('should not get tasks without authentication', async () => {
      const response = await request(app)
        .get('/api/tasks')
        .expect(401);

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

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

      const taskData = {
        street: street.id,
        description: 'Clean the sidewalk',
      };

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

      expect(response.body).toHaveProperty('description', taskData.description);
      expect(response.body).toHaveProperty('street', street.id);
    });

    it('should not create task without authentication', async () => {
      const { user } = await createTestUser();
      const street = await createTestStreet(user.id);

      const taskData = {
        street: street.id,
        description: 'Clean the sidewalk',
      };

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

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

  describe('PUT /api/tasks/:id', () => {
    it('should complete a task', async () => {
      const { user, token } = await createTestUser();
      const street = await createTestStreet(user.id);
      const task = await createTestTask(user.id, street.id, {
        status: 'pending',
        completedBy: null
      });

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

      expect(response.body).toHaveProperty('status', 'completed');
      expect(response.body).toHaveProperty('completedBy', user.id);
    });

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

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

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

    it('should not complete task without authentication', async () => {
      const { user } = await createTestUser();
      const street = await createTestStreet(user.id);
      const task = await createTestTask(user.id, street.id);

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

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

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

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

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