const addAddress = async (req: Request, res: Response) => {
    const patientId = req.params.patientId;
    const newAddress = req.body.newAddress;
    try {
        const existingPatient = await patient.findOne({ _id: patientId });
        if (!existingPatient) {
            return res.status(404).json({ message: "Patient not found" });
        }
        existingPatient.address.push(newAddress);
        await existingPatient.save();
        res.json({ message: "Address added successfully" });
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Internal Server Error" });
    }
};

const archiveMedicine = async (req: Request, res: Response) => {
    const id = req.params.id;
    try {
        const existingMedicine = await medicine.findById(id);
        if (!existingMedicine) {
            return res.status(404).send({ message: "Medicine not found" });
        }
        existingMedicine.isArchived = !existingMedicine.isArchived;
        const updatedMed = await existingMedicine.save();
        res.status(200).send(updatedMed);
    } catch (error) {
        res.status(400).send(error);
    }
};

const listAdminstrators = async (req: Request, res: Response) => {
    const adminstrators = adminstrator
        .find({})
        .then((admns) => res.status(200).json(admns))
        .catch((err) => {
            res.status(400).json(err);
        });
};

import NotFoundImg from "./assets/photos/not-found.png";

<Container>
    <div>
        <h1>404 - Page Not Found</h1>
        <p>Sorry, the page you're looking for does not exist.</p>
        <img src={NotFoundImg} />
    </div>
    <Button variant="contained" component={Link} to="/patient/medicines">
        {" "}
        Return to Homepage{" "}
    </Button>
</Container>;

<AppBar position="static">
    <Toolbar>
        <IconButton>
            <MenuIcon />
        </IconButton>
        <Typography>{props.title}</Typography>
        {props.cart && (
            <IconButton component={Link} to="/patient/cart">
                <ShoppingCartIcon />
            </IconButton>
        )}
        <IconButton component={Link} onClick={handleLogout}>
            <LogoutIcon />
        </IconButton>
    </Toolbar>
</AppBar>

test('should throw an error if email is invalid', async () => {
        const admin = new Adminstrator({
            username: 'testuser',
            passwordHash: 'password',
            email: 'invalidemail',
        });
        await expect(admin.save()).rejects.toThrow('invalid email');
    });

test('should throw an error if patient is missing', async () => {
        const cartWithoutPatient = {
            medicines: [
                { medName: 'Medicine1', medPrice: 10, medQuantity: 2 },
                { medName: 'Medicine2', medPrice: 15, medQuantity: 3 },
            ],
        };

        const cart = new Cart(cartWithoutPatient);
        await expect(cart.save()).rejects.toThrow('Cart validation failed: patient: Path `patient` is required.');
    });

test('should throw an error if chatName is missing', async () => {
        const chatWithoutChatName = {
            isGroupChat: false,
            users: [new Types.ObjectId(), new Types.ObjectId()],
            createdAt: new Date(),
            updatedAt: new Date(),
        };

        const chat = new ChatModel(chatWithoutChatName);
        await expect(chat.save()).rejects.toThrow('Chat validation failed: chatName: Path `chatName` is required.');
    });

test('should throw an error if name is missing', async () => {
    const medicineWithoutName = {
      medicinalUse: 'Pain Relief',
      details: { description: 'Test description', activeIngredients: ['Ingredient1', 'Ingredient2'] },
      price: 20,
      availableQuantity: 100,
      sales: 50,
      image: 'test_image.jpg',
      overTheCounter: true,
      isArchived: false,
    };

    const medicine = new Medicine(medicineWithoutName);
    await expect(medicine.save()).rejects.toThrow('Medicine validation failed: name: Path `name` is required.');
  });

test('should throw an error if sender is missing', async () => {
        const messageWithoutSender = {
            content: 'Test message content',
            chat: new Types.ObjectId(),
            readBy: [new Types.ObjectId()],
            createdAt: new Date(),
            updatedAt: new Date(),
        };

        const message = new MessageModel(messageWithoutSender);
        await expect(message.save()).rejects.toThrow('Message validation failed: sender: Path `sender` is required.');
    });

test('should throw an error if patient is missing', async () => {
        const orderWithoutPatient = {
            status: 'pending',
            date: new Date(),
            total: 100,
            address: 'Test address',
            paymentMethod: 'cash on delivery',
            medicines: [{ medName: 'Medicine1', medPrice: 10, medQuantity: 2 }],
        };

        const order = new Order(orderWithoutPatient);
        await expect(order.save()).rejects.toThrow('Order validation failed: patient: Path `patient` is required.');
    });

test('should throw an error if name is missing', async () => {
        const packageWithoutName = {
            price: 50,
            discountOnDoctorSessions: 10,
            discountOnMedicine: 5,
            discountForFamily: 15,
        };

        const packageItem = new Package(packageWithoutName);
        await expect(packageItem.save()).rejects.toThrow('Package validation failed: name: Path `name` is required.');
    });

test('should throw an error if name is missing', async () => {
        const patientWithoutName = {
            email: "email@gmail.com",
            passwordHash: "password",
            username: "username",
            nationalId: '123456789',
            dateOfBirth: new Date(),
            gender: 'male',
            mobileNumber: '+12345678',
            emergencyContact: {
                name: 'EmergencyContact',
                mobileNumber: '+12345678',
                relation: 'parent',
            },
        };

        const patient = new Patient(patientWithoutName);
        await expect(patient.save()).rejects.toThrow('Patient validation failed: name: Path `name` is required.');
    });

test('should throw an error if dateOfBirth is missing', async () => {
        const pharmacistWithoutDateOfBirth = {
            email: "email@gmail.com",
            passwordHash: "password",
            username: "username",
            name: 'John Doe',
            hourlyRate: 50,
            affiliation: 'Pharmacy ABC',
            education: 'Pharmacist Degree',
            files: [{ filename: 'file1.txt', path: '/path/to/file1.txt' }],
            status: 'pending',
        };

        const pharmacist = new Pharmacist(pharmacistWithoutDateOfBirth);
        await expect(pharmacist.save()).rejects.toThrow('pharmacist validation failed: dateOfBirth: Path `dateOfBirth` is required.');
    });

test('should throw an error if doctor is missing', async () => {
        const prescriptionWithoutDoctor = {
            patient: new Types.ObjectId(),
            medicine: [{ medId: new Types.ObjectId(), dailyDosage: 1 }],
            date: new Date(),
            filled: false,
        };

        const prescription = new Prescription(prescriptionWithoutDoctor);
        await expect(prescription.save()).rejects.toThrow('Prescription validation failed: doctor: Path `doctor` is required.');
    });