import pytest
import logging
from fastapi.testclient import TestClient
from hypothesis import given, strategies as st, settings
from bson import ObjectId
from pos_system.server import app
from pos_system.database import get_db
from datetime import datetime

client = TestClient(app)
logger = logging.getLogger(__name__)


def clear_db():
  db = get_db()
  db.orders.delete_many({})
  db.items.delete_many({})
  db.users.delete_many({})


@pytest.fixture(autouse=True)
def run_around_tests():
  clear_db()
  yield
  clear_db()


def create_test_user():
  user_data = {
      "username": "testuser",
      "email": "testuser@example.com",
      "password": "testpassword",
      "full_name": "Test User",
      "is_active": True,
      "is_superuser": False
  }
  response = client.post("/users/register", json=user_data)
  assert response.status_code == 200, f"Failed to create user: {response.text}"
  return response.json()


def login_test_user():
  login_data = {
      "username": "testuser",
      "password": "testpassword"
  }
  response = client.post("/token", data=login_data)
  assert response.status_code == 200
  return response.json()["access_token"]


def create_test_item(token):
  headers = {"Authorization": f"Bearer {token}"}
  response = client.post(
      "/items/",
      headers=headers,
      json={"name": "Test Item", "price": 10.99,
            "quantity": 100, "unit": "piece"}
  )
  assert response.status_code == 200
  return response.json()["_id"]


@pytest.fixture
def auth_headers():
  create_test_user()
  token = login_test_user()
  return {"Authorization": f"Bearer {token}"}


def test_create_order(auth_headers):
  logger.info("Testing create order")
  item_id = create_test_item(auth_headers["Authorization"].split()[1])
  order_data = {
      "items": [{"item_id": item_id, "quantity": 2}],
      "total_amount": 21.98,
      "payment_method": "credit_card"
  }
  response = client.post("/orders/", json=order_data, headers=auth_headers)
  assert response.status_code == 200
  assert "_id" in response.json()
  logger.info(f"Created order with ID: {response.json()['_id']}")


def test_read_orders(auth_headers):
  logger.info("Testing read orders")
  item_id = create_test_item(auth_headers["Authorization"].split()[1])
  order_data = {
      "items": [{"item_id": item_id, "quantity": 2}],
      "total_amount": 21.98,
      "payment_method": "credit_card"
  }
  client.post("/orders/", json=order_data, headers=auth_headers)
  response = client.get("/orders/", headers=auth_headers)
  assert response.status_code == 200
  orders = response.json()
  assert len(orders) == 1
  assert orders[0]["total_amount"] == 21.98
  logger.info(f"Retrieved {len(orders)} orders")


def test_read_order(auth_headers):
  logger.info("Testing read single order")
  item_id = create_test_item(auth_headers["Authorization"].split()[1])
  order_data = {
      "items": [{"item_id": item_id, "quantity": 2}],
      "total_amount": 21.98,
      "payment_method": "credit_card"
  }
  create_response = client.post(
      "/orders/", json=order_data, headers=auth_headers)
  order_id = create_response.json()["_id"]
  response = client.get(f"/orders/{order_id}", headers=auth_headers)
  assert response.status_code == 200
  assert response.json()["total_amount"] == 21.98
  logger.info(f"Retrieved order with ID: {order_id}")


def test_update_order(auth_headers):
  logger.info("Testing update order")
  item_id = create_test_item(auth_headers["Authorization"].split()[1])
  order_data = {
      "items": [{"item_id": item_id, "quantity": 2}],
      "total_amount": 21.98,
      "payment_method": "credit_card"
  }
  create_response = client.post(
      "/orders/", json=order_data, headers=auth_headers)
  order_id = create_response.json()["_id"]
  update_data = {
      "items": [{"item_id": item_id, "quantity": 3}],
      "total_amount": 32.97,
      "payment_method": "cash"
  }
  response = client.put(f"/orders/{order_id}",
                        json=update_data, headers=auth_headers)
  assert response.status_code == 200
  assert response.json()["total_amount"] == 32.97
  assert response.json()["payment_method"] == "cash"
  logger.info(f"Updated order with ID: {order_id}")


def test_delete_order(auth_headers):
  logger.info("Testing delete order")
  item_id = create_test_item(auth_headers["Authorization"].split()[1])
  order_data = {
      "items": [{"item_id": item_id, "quantity": 2}],
      "total_amount": 21.98,
      "payment_method": "credit_card"
  }
  create_response = client.post(
      "/orders/", json=order_data, headers=auth_headers)
  order_id = create_response.json()["_id"]
  response = client.delete(f"/orders/{order_id}", headers=auth_headers)
  assert response.status_code == 200
  assert response.json()["message"] == "Order deleted successfully"
  get_response = client.get(f"/orders/{order_id}", headers=auth_headers)
  assert get_response.status_code == 404
  logger.info(f"Deleted order with ID: {order_id}")


@given(
    st.lists(
        st.fixed_dictionaries({
            "quantity": st.integers(min_value=1, max_value=10)
        }),
        min_size=1,
        max_size=5
    ),
    st.floats(min_value=0.01, max_value=1000,
              allow_nan=False, allow_infinity=False),
    st.sampled_from(["credit_card", "cash", "paypal"])
)
@settings(max_examples=50)
def test_create_order_property(auth_headers, items, total_amount, payment_method):
  clear_db()
  create_test_user()
  token = login_test_user()
  auth_headers = {"Authorization": f"Bearer {token}"}
  item_id = create_test_item(token)
  for item in items:
    item["item_id"] = item_id  # Use the same item_id for all items
  order_data = {
      "items": items,
      "total_amount": total_amount,
      "payment_method": payment_method
  }
  response = client.post("/orders/", json=order_data, headers=auth_headers)
  assert response.status_code == 200
  assert "_id" in response.json()
  order_id = response.json()["_id"]
  get_response = client.get(f"/orders/{order_id}", headers=auth_headers)
  assert get_response.status_code == 200
  retrieved_order = get_response.json()
  assert retrieved_order["total_amount"] == total_amount
  assert retrieved_order["payment_method"] == payment_method
  assert len(retrieved_order["items"]) == len(items)


@given(
    st.lists(
        st.fixed_dictionaries({
            "total_amount": st.floats(min_value=0.01, max_value=1000, allow_nan=False, allow_infinity=False),
            "payment_method": st.sampled_from(["credit_card", "cash", "paypal"])
        }),
        min_size=1,
        max_size=10
    )
)
@settings(max_examples=20)
def test_read_orders_property(auth_headers, orders):
  clear_db()
  create_test_user()
  token = login_test_user()
  auth_headers = {"Authorization": f"Bearer {token}"}
  item_id = create_test_item(token)
  for order in orders:
    order_data = {
        "items": [{"item_id": item_id, "quantity": 1}],
        "total_amount": order["total_amount"],
        "payment_method": order["payment_method"]
    }
    client.post("/orders/", json=order_data, headers=auth_headers)
  response = client.get("/orders/", headers=auth_headers)
  assert response.status_code == 200
  retrieved_orders = response.json()
  assert len(retrieved_orders) == len(orders)
  for retrieved_order in retrieved_orders:
    assert "total_amount" in retrieved_order
    assert "payment_method" in retrieved_order


@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_makereport(item, call):
  outcome = yield
  report = outcome.get_result()
  if report.when == "call" and report.failed:
    if "hypothesis" in item.keywords:
      logger.error(f"Property test failed: {item.name}")
      logger.error(f"Falsifying example: {call.excinfo.value}")


if __name__ == "__main__":
  pytest.main([__file__])