const User = require('../../models/User');
const mongoose = require('mongoose');

describe('User Model', () => {
  describe('Schema Validation', () => {
    it('should create a valid user', async () => {
      const userData = {
        name: 'Test User',
        email: 'test@example.com',
        password: 'hashedPassword123',
      };

      const user = new User(userData);
      const savedUser = await user.save();

      expect(savedUser._id).toBeDefined();
      expect(savedUser.name).toBe(userData.name);
      expect(savedUser.email).toBe(userData.email);
      expect(savedUser.password).toBe(userData.password);
      expect(savedUser.isPremium).toBe(false); // Default value
      expect(savedUser.points).toBe(0); // Default value
      expect(savedUser.adoptedStreets).toEqual([]);
      expect(savedUser.completedTasks).toEqual([]);
    });

    it('should require name field', async () => {
      const user = new User({
        email: 'test@example.com',
        password: 'password123',
      });

      let error;
      try {
        await user.save();
      } catch (err) {
        error = err;
      }

      expect(error).toBeDefined();
      expect(error.errors.name).toBeDefined();
    });

    it('should require email field', async () => {
      const user = new User({
        name: 'Test User',
        password: 'password123',
      });

      let error;
      try {
        await user.save();
      } catch (err) {
        error = err;
      }

      expect(error).toBeDefined();
      expect(error.errors.email).toBeDefined();
    });

    it('should require password field', async () => {
      const user = new User({
        name: 'Test User',
        email: 'test@example.com',
      });

      let error;
      try {
        await user.save();
      } catch (err) {
        error = err;
      }

      expect(error).toBeDefined();
      expect(error.errors.password).toBeDefined();
    });

    it('should enforce unique email constraint', async () => {
      const email = 'duplicate@example.com';

      await User.create({
        name: 'User 1',
        email,
        password: 'password123',
      });

      let error;
      try {
        await User.create({
          name: 'User 2',
          email,
          password: 'password456',
        });
      } catch (err) {
        error = err;
      }

      expect(error).toBeDefined();
      expect(error.code).toBe(11000); // MongoDB duplicate key error
    });

    it('should not allow negative points', async () => {
      const user = new User({
        name: 'Test User',
        email: 'test@example.com',
        password: 'password123',
        points: -10,
      });

      let error;
      try {
        await user.save();
      } catch (err) {
        error = err;
      }

      expect(error).toBeDefined();
      expect(error.errors.points).toBeDefined();
    });
  });

  describe('Default Values', () => {
    it('should set default values correctly', async () => {
      const user = await User.create({
        name: 'Default Test',
        email: 'default@example.com',
        password: 'password123',
      });

      expect(user.isPremium).toBe(false);
      expect(user.points).toBe(0);
      expect(user.adoptedStreets).toEqual([]);
      expect(user.completedTasks).toEqual([]);
      expect(user.posts).toEqual([]);
      expect(user.events).toEqual([]);
    });
  });

  describe('Relationships', () => {
    it('should store adopted streets references', async () => {
      const streetId = new mongoose.Types.ObjectId();

      const user = await User.create({
        name: 'Test User',
        email: 'test@example.com',
        password: 'password123',
        adoptedStreets: [streetId],
      });

      expect(user.adoptedStreets).toHaveLength(1);
      expect(user.adoptedStreets[0].toString()).toBe(streetId.toString());
    });

    it('should store completed tasks references', async () => {
      const taskId = new mongoose.Types.ObjectId();

      const user = await User.create({
        name: 'Test User',
        email: 'test@example.com',
        password: 'password123',
        completedTasks: [taskId],
      });

      expect(user.completedTasks).toHaveLength(1);
      expect(user.completedTasks[0].toString()).toBe(taskId.toString());
    });

    it('should store multiple posts references', async () => {
      const postId1 = new mongoose.Types.ObjectId();
      const postId2 = new mongoose.Types.ObjectId();

      const user = await User.create({
        name: 'Test User',
        email: 'test@example.com',
        password: 'password123',
        posts: [postId1, postId2],
      });

      expect(user.posts).toHaveLength(2);
      expect(user.posts[0].toString()).toBe(postId1.toString());
      expect(user.posts[1].toString()).toBe(postId2.toString());
    });
  });

  describe('Timestamps', () => {
    it('should automatically set createdAt and updatedAt', async () => {
      const user = await User.create({
        name: 'Test User',
        email: 'timestamp@example.com',
        password: 'password123',
      });

      expect(user.createdAt).toBeDefined();
      expect(user.updatedAt).toBeDefined();
      expect(user.createdAt).toBeInstanceOf(Date);
      expect(user.updatedAt).toBeInstanceOf(Date);
    });

    it('should update updatedAt on modification', async () => {
      const user = await User.create({
        name: 'Test User',
        email: 'update@example.com',
        password: 'password123',
      });

      const originalUpdatedAt = user.updatedAt;

      // Wait a bit to ensure timestamp difference
      await new Promise(resolve => setTimeout(resolve, 10));

      user.points = 100;
      await user.save();

      expect(user.updatedAt.getTime()).toBeGreaterThan(originalUpdatedAt.getTime());
    });
  });

  describe('Virtual Properties', () => {
    it('should support earnedBadges virtual', () => {
      const user = new User({
        name: 'Test User',
        email: 'test@example.com',
        password: 'password123',
      });

      // Virtual should be defined (actual population happens via populate())
      expect(user.schema.virtuals.earnedBadges).toBeDefined();
    });

    it('should include virtuals in JSON output', async () => {
      const user = await User.create({
        name: 'Test User',
        email: 'virtuals@example.com',
        password: 'password123',
      });

      const userJSON = user.toJSON();
      expect(userJSON).toHaveProperty('id'); // Virtual id from _id
    });
  });

  describe('Premium Status', () => {
    it('should allow setting premium status', async () => {
      const user = await User.create({
        name: 'Premium User',
        email: 'premium@example.com',
        password: 'password123',
        isPremium: true,
      });

      expect(user.isPremium).toBe(true);
    });

    it('should allow toggling premium status', async () => {
      const user = await User.create({
        name: 'Test User',
        email: 'toggle@example.com',
        password: 'password123',
        isPremium: false,
      });

      user.isPremium = true;
      await user.save();

      const updatedUser = await User.findById(user._id);
      expect(updatedUser.isPremium).toBe(true);
    });
  });

  describe('Points Management', () => {
    it('should allow incrementing points', async () => {
      const user = await User.create({
        name: 'Test User',
        email: 'points@example.com',
        password: 'password123',
        points: 100,
      });

      user.points += 50;
      await user.save();

      expect(user.points).toBe(150);
    });

    it('should allow decrementing points', async () => {
      const user = await User.create({
        name: 'Test User',
        email: 'deduct@example.com',
        password: 'password123',
        points: 100,
      });

      user.points -= 25;
      await user.save();

      expect(user.points).toBe(75);
    });
  });

  describe('Profile Picture', () => {
    it('should store profile picture URL', async () => {
      const user = await User.create({
        name: 'Test User',
        email: 'pic@example.com',
        password: 'password123',
        profilePicture: 'https://example.com/pic.jpg',
        cloudinaryPublicId: 'user_123',
      });

      expect(user.profilePicture).toBe('https://example.com/pic.jpg');
      expect(user.cloudinaryPublicId).toBe('user_123');
    });
  });
});