from locust import HttpUser, task, between
import random, json

"""
NOTA: algunas rutas requieren autontificación middleware 'auth' y 'role:admin'
estas rutas se encuentran protegidas y solo pueden ser accedidas por usuarios autenticados con el rol de administrador.
por lo tanto si vas a probar estas rutas debes desactivar temporalmente estos middlewares en el archivo Kernel.php  respectivamente. 
esto se hace con el fin de facilitar las pruebas de carga y rendimiento sin la necesidad de autenticación.
asegurate de volver a activar los middlewares despues de las pruebas.
y solo realizar esto en entornos de desarrollo o pruebas local, nunca en produccion.
"""



class WebAdminUser(HttpUser):
    host = "http://localhost:8014" 
    wait_time = between(1, 2)


    def on_start(self):
        response = self.client.post("administrator/login",{
            "email": "info@terpel.co",
            "password": "123"
        })

    

    @task(1)
    def workspace_post(self):
        self.client.post("/administrator/options/workspace", data={"workspace": "default"})

    @task(1)
    def permits_save(self):
        self.client.post("/administrator/permits/save", data={"permit": "write"})

    @task(1)
    def permits_search(self):
        self.client.post("/administrator/permits/search", data={"query": "read"})

    @task(1)
    def roles_delete(self):
        self.client.post("/administrator/roles/delete", data={"id": 1})

    @task(1)
    def roles_store(self):
        self.client.post("/administrator/roles/store", data={"name": "Admin"})

    @task(1)
    def roles_update(self):
        self.client.post("/administrator/roles/update", data={"id": 1, "name": "Updated Role"})

    @task(1)
    def rules_applied_customers(self):
        self.client.post("/administrator/rules/applied/customers", data={"rule_id": 1})

    @task(1)
    def rules_applied_equipments(self):
        self.client.post("/administrator/rules/applied/equipments", data={"equipment_ids": [1, 2, 3]})

    @task(1)
    def rules_applied_templates(self):
        self.client.post("/administrator/rules/applied/templates", data={"template_id": 1})

    @task(1)
    def rules_copy(self):
        self.client.post("/administrator/rules/copyRule/1", data={"motive": "duplicar"})

    @task(1)
    def rules_delete(self):
        self.client.delete("/administrator/rules/delete/1")

    @task(1)
    def rules_store(self):
        self.client.post("/administrator/rules/store", data={"name": "Nueva Regla"})

    @task(1)
    def rules_update(self):
        self.client.put("/administrator/rules/update/1", data={"name": "Regla Actualizada"})

    @task(1)
    def users_store(self):
        self.client.post("/administrator/users/store", data={
            "name": "Test User",
            "email": "test@example.com",
            "password": "secret"
        })

    @task(1)
    def dashboard(self):
        self.client.get("/administrator/")

    @task(1)
    def list_critical(self):
        self.client.get("/administrator/dashboard/listOfCritical")

    @task(1)
    def profiles_index(self):
        self.client.get("/administrator/profiles/")

    @task(1)
    def users_index(self):
        self.client.get("/administrator/users")

    @task(1)
    def users_create(self):
        self.client.get("/administrator/users/create")

    @task(1)
    def users_show(self):
        self.client.get("/administrator/users/show/1")

    @task(1)
    def users_edit(self):
        self.client.get("/administrator/users/edit/1")

    @task(1)
    def roles_index(self):
        self.client.get("/administrator/roles")

    @task(1)
    def permits_index(self):
        self.client.get("/administrator/permits")

    @task(1)
    def rules_index(self):
        self.client.get("/administrator/rules")

    @task(1)
    def rules_elements(self):
        self.client.get("/administrator/rules/elements/typeA")

    @task(1)
    def rules_create(self):
        self.client.get("/administrator/rules/create")

    @task(1)
    def rules_show(self):
        self.client.get("/administrator/rules/show/1")

    @task(1)
    def rules_get_group(self):
        self.client.get("/administrator/rules/getGroup/1")


    """
    #ruta excluida por que sun unico funcionamiento es hacer una redireccion a una vista blade 
    """
    # @task(1)
    # def rules_edit(self):
    #     self.client.get("/administrator/rules/edit/1")

    @task(1)
    def rules_constants(self):
        self.client.get("/administrator/constants")

    @task(1)
    def rules_applied_index(self):
        self.client.get("/administrator/rules/applied")

    @task(1)
    def home_page(self):
        self.client.get("/")

    @task(1)
    def mail_view(self):
        self.client.get("/mailview")

    @task(1)
    def report_by_sample(self):
        sample_id = random.randint(1, 100)
        self.client.get(f"/ext/history/report/{sample_id}")

    @task(1)
    def view_report_from_mail(self):
        self.client.get("/ext/history/mailReport")
#-----------------------------------------------------------

    # 🔹 Rules Applied
    @task(1)
    def rules_applied_components(self):
        self.client.post("/administrator/rules/applied/components")

    @task(1)
    def rules_applied_add(self):
        self.client.post("/administrator/rules/applied/add")

    @task(1)
    def rules_applied_delete(self):
        self.client.post("/administrator/rules/applied/delete")

    @task(1)
    def rules_download(self):
        self.client.get("/administrator/rules/download")

    # 🔹 Lubricant Rules
    @task(1)
    def lubricant_oil_weights(self):
        self.client.get("/administrator/rules/lubricant/oilWeights")

    @task(1)
    def lubricant_references_and_brands(self):
        self.client.post("/administrator/rules/lubricant/referencesAndBrands", data={"brand": "Shell"})

    @task(1)
    def lubricant_brands(self):
        self.client.post("/administrator/rules/lubricant/brands", data={
            "oilReferences": [1,2]
        })

    # 🔹 Rules Rework
    @task(1)
    def rules_rework_index(self):
        self.client.get("/administrator/rules/rework/")

    @task(1)
    def rules_rework_create(self):
        self.client.get("/administrator/rules/rework/create")

    @task(1)
    def rules_rework_store(self):
        self.client.post("/administrator/rules/rework/store", data={"name": "Nueva regla rework"})

    @task(1)
    def rules_rework_show(self):
        self.client.get("/administrator/rules/rework/show/1")

    @task(1)
    def rules_rework_edit(self):
        self.client.get("/administrator/rules/rework/edit/1")

    @task(1)
    def rules_rework_get(self):
        self.client.get("/administrator/rules/rework/getRule")

    @task(1)
    def rules_rework_update(self):
        self.client.put("/administrator/rules/rework/update/1", data={"name": "Regla actualizada"})

    @task(1)
    def rules_rework_delete(self):
        self.client.delete("/administrator/rules/rework/delete/1")

    # 🔹 Rules Visc Rework
    @task(1)
    def rules_visc_create(self):
        self.client.get("/administrator/rules/rework/createVisc")

    @task(1)
    def rules_visc_store(self):
        self.client.post("/administrator/rules/rework/storeVisc", data={"viscosity": "10W40"})

    @task(1)
    def rules_visc_show(self):
        self.client.post("/administrator/rules/rework/showVisc/1", data={})


    """
       # esta ruta genera un error 500 en locust por que su unico funcionamiento es hacer una redireccion a una vista blade  
    """
    # @task(1)
    # def rules_visc_edit(self):
    #     self.client.get("/administrator/rules/rework/editVisc/1")

    @task(1)
    def rules_visc_get(self):
        self.client.get("/administrator/rules/rework/getRuleVisc")

    @task(1)
    def rules_visc_update(self):
        self.client.put("/administrator/rules/rework/updateVisc/1", data={"viscosity": "5W30"})

    @task(1)
    def rules_visc_delete(self):
        self.client.delete("/administrator/rules/rework/deleteVisc/1")

    # 🔹 Customers
    @task(1)
    def customers_index(self):
        self.client.get("/administrator/customers")

    @task(1)
    def customers_create(self):
        self.client.get("/administrator/customers/create")

    @task(1)
    def customers_store(self):
        self.client.post("/administrator/customers/store", data={
            "name": "Cliente Test",
            "email": "cliente@example.com",
            "password": "123456"
        })

        """
        #el funcionamiento de etsa ruta es verificar que el cliente exista y si existe
        #genera una redireccion a la pagina anterior con un mensaje flash, esto genera un error 500 en locust
        #lo que genera que no se pueda probar la funcionalidad, se debe corregir en el controlador para que retorne
        #una respuesta json y asi poder probar la funcionalidad
    """
    # @task(1)
    # def customers_show(self):
    #     self.client.get("/administrator/customers/show/1")

    @task(1)
    def customers_edit(self):
        self.client.get("/administrator/customers/edit/1")

    @task(1)
    def customers_update(self):
        self.client.put("/administrator/customers/update/1", data={"name": "Cliente Actualizado"})

    @task(1)
    def customers_delete(self):
        self.client.post("/administrator/customers/delete", data={"id": 1})

    @task(1)
    def customers_state(self):
        self.client.put("/administrator/customers/state/1", data={"state": "active"})



    """
    # ruta comentada por que contiene un return back, lo que busca hacer una redireccion a la pagina anterior
    # esto genera un error 500 en locust, se debe corregir en el controlador para que retorne una respuesta json
    # y asi poder probar la funcionalidad

    # requerimientos de la data:
    # - el id debe ser un uuid valido de un cliente existente
    # - las contraseñas deben cumplir con las reglas de validacion definidas en PasswordValidation
    # - las contraseñas deben coincidir
    # - las contraseñas deben tener entre 8 y 30 caracteres
   
    """
    # @task(1)
    # def customers_password(self):
    #     self.client.put("/administrator/customers/password/2e52aa77-4628-11eb-a3d5-e454e88f4bc6", data={
    #         "password":"Ro#1234567880",
    #         "password_confirmation":"Ro#1234567880"
    #     })

    @task(1)
    def customers_autologin(self):
        self.client.post("/administrator/customers/autologin", data={
            "email":"info@terpel.co",
            "password":"123"
        })

    @task(1)
    def customers_admin_autologin(self):
        self.client.post("/administrator/customers/admin/autologin", data={
            "email":"info@terpel.co",
            "password":"123"
        })

    @task(1)
    def customers_show_equipment(self):
        self.client.post("/administrator/customers/show/equipment")
    

    # ---------------------------
    # Customer Users
    # ---------------------------
    @task(2)
    def customer_users_index(self):
        self.client.get("/administrator/customers/users")

    @task(1)
    def customer_users_create(self):
        self.client.get("/administrator/customers/users/create")

    @task(2)
    def customer_users_store(self):
        self.client.post("/administrator/customers/users/store", data={
            "name": "CU Test",
            "email": f"cu_test_{random.randint(1,10000)}@example.com",
            "password": "123456",
            "customer_id": 1
        })

    @task(1)
    def customer_users_show(self):
        user_id = random.randint(1, 20)
        self.client.get(f"/administrator/customers/users/show/{user_id}")

    @task(1)
    def customer_users_update(self):
        user_id = random.randint(1, 20)
        self.client.put(f"/administrator/customers/users/update/{user_id}", data={
            "name": "CU Updated"
        })

    @task(1)
    def customer_users_delete(self):
        self.client.delete("/administrator/customers/users/delete", json={"id": random.randint(1, 20)})

    @task(1)
    def customer_users_components(self):
        user_id = random.randint(1, 20)
        self.client.get(f"/administrator/customers/users/{user_id}/components")

    @task(1)
    def customer_users_components_list(self):
        user_id = random.randint(1, 20)
        self.client.get(f"/administrator/customers/users/{user_id}/components/list")

    @task(1)
    def customer_users_components_store(self):
        self.client.post("/administrator/customers/users/components/store", data={
            "user_id": random.randint(1, 20),
            "components": [1,2,3]
        })

    @task(1)
    def customer_users_components_update(self):
        user_id = random.randint(1, 20)
        self.client.put(f"/administrator/customers/users/{user_id}/components/update", json={
            "components": [2,3]
        })

    @task(1)
    def customer_get_data_user(self):
        self.client.get(f"/administrator/customer/getDataUser/{random.randint(1,20)}")

    @task(1)
    def customer_save_emails(self):
        self.client.post("/administrator/customer/saveEmails", data={
            "user_id": random.randint(1,20),
            "emails": "a@example.com,b@example.com"
        })

    # ---------------------------
    # Receptionists
    # ---------------------------
    @task(2)
    def receptionists_index(self):
        self.client.get("/administrator/receptionists")

    @task(1)
    def receptionists_create(self):
        self.client.get("/administrator/receptionists/create")

    @task(2)
    def receptionists_store(self):
        self.client.post("/administrator/receptionists/store", data={
            "name": "Rec Test",
            "email": f"rec_{random.randint(1,10000)}@example.com",
            "password": "123456"
        })

    @task(1)
    def receptionists_show(self):
        self.client.get(f"/administrator/receptionists/show/{random.randint(1,20)}")

    @task(1)
    def receptionists_edit(self):
        self.client.get(f"/administrator/receptionists/edit/{random.randint(1,20)}")

    @task(1)
    def receptionists_update(self):
        self.client.put(f"/administrator/receptionists/update/{random.randint(1,20)}", data={"name":"Rec Updated"})

    @task(1)
    def receptionists_state(self):
        self.client.put(f"/administrator/receptionists/state/{random.randint(1,20)}", data={"state":"active"})

    @task(1)
    def receptionists_password(self):
        self.client.put(f"/administrator/receptionists/password/{random.randint(1,20)}", data={"password":"newpass123"})

    @task(1)
    def receptionists_delete(self):
        self.client.post("/administrator/receptionists/delete", data={"id": random.randint(1,20)})

    # ---------------------------
    # Operators
    # ---------------------------
    @task(2)
    def operators_index(self):
        self.client.get("/administrator/operators")

    @task(1)
    def operators_create(self):
        self.client.get("/administrator/operators/create")

    @task(2)
    def operators_store(self):
        self.client.post("/administrator/operators/store", data={
            "name": "Op Test",
            "email": f"op_{random.randint(1,10000)}@example.com",
            "password": "123456"
        })

    @task(1)
    def operators_show(self):
        self.client.get(f"/administrator/operators/show/{random.randint(1,20)}")

    @task(1)
    def operators_edit(self):
        self.client.get(f"/administrator/operators/edit/{random.randint(1,20)}")

    @task(1)
    def operators_update(self):
        self.client.put(f"/administrator/operators/update/{random.randint(1,20)}", data={"name":"Op Updated"})

    @task(1)
    def operators_state(self):
        self.client.put(f"/administrator/operators/state/{random.randint(1,20)}", data={"state":"active"})

    @task(1)
    def operators_password(self):
        self.client.put(f"/administrator/operators/password/{random.randint(1,20)}", data={"password":"newpass123"})

    @task(1)
    def operators_delete(self):
        self.client.post("/administrator/operators/delete", data={"id": random.randint(1,20)})

    # ---------------------------
    # Supervisors
    # ---------------------------
    @task(2)
    def supervisors_index(self):
        self.client.get("/administrator/supervisors")

    @task(1)
    def supervisors_create(self):
        self.client.get("/administrator/supervisors/create")

    @task(2)
    def supervisors_store(self):
        self.client.post("/administrator/supervisors/store", data={
            "name": "Sup Test",
            "email": f"sup_{random.randint(1,10000)}@example.com",
            "password": "123456"
        })

    @task(1)
    def supervisors_show(self):
        self.client.get(f"/administrator/supervisors/show/{random.randint(1,20)}")

    @task(1)
    def supervisors_edit(self):
        self.client.get(f"/administrator/supervisors/edit/{random.randint(1,20)}")

    @task(1)
    def supervisors_update(self):
        self.client.put(f"/administrator/supervisors/update/{random.randint(1,20)}", data={"name":"Sup Updated"})

    @task(1)
    def supervisors_state(self):
        self.client.put(f"/administrator/supervisors/state/{random.randint(1,20)}", data={"state":"active"})

    @task(1)
    def supervisors_password(self):
        self.client.put(f"/administrator/supervisors/password/{random.randint(1,20)}", data={"password":"newpass123"})

    @task(1)
    def supervisors_delete(self):
        self.client.post("/administrator/supervisors/delete", data={"id": random.randint(1,20)})



        

    # ---------------------------
    # Accounts (FleetsController)
    # ---------------------------
    @task(2)
    def accounts_index(self):
        self.client.get("/administrator/accounts")

    @task(1)
    def accounts_create(self):
        self.client.post("/administrator/accounts/create", data={
            "name": f"Fleet {random.randint(1,10000)}",
            "owner": "AutoTest"
        })

    @task(1)
    def accounts_edit(self):
        self.client.post("/administrator/accounts/edit", data={
            "id": random.randint(1,50),
            "name": "Edited Fleet"
        })

    @task(1)
    def accounts_update(self):
        self.client.post("/administrator/accounts/update", data={
            "id": random.randint(1,50),
            "name": "Updated Fleet"
        })

    @task(1)
    def accounts_delete(self):
        self.client.post("/administrator/accounts/delete", data={"id": random.randint(1,50)})

    @task(1)
    def accounts_search(self):
        self.client.post("/administrator/accounts/search", data={"q": "Test"})

    # Equipments under accounts (EquipmentController)
    @task(1)
    def accounts_equipments_index(self):
        self.client.get("/administrator/accounts/equipments")

    @task(1)
    def accounts_equipments_create(self):
        self.client.get("/administrator/accounts/equipments/create")

    @task(2)
    def accounts_equipments_store(self):
        self.client.post("/administrator/accounts/equipments/store", data={
            "unit_id": f"U{random.randint(1000,9999)}",
            "plate": f"PL{random.randint(100,999)}",
            "account_id": random.randint(1,50)
        })

    @task(1)
    def accounts_equipments_edit(self):
        self.client.get("/administrator/accounts/equipments/edit")

    @task(1)
    def accounts_equipments_update(self):
        eid = random.randint(1,200)
        self.client.put(f"/administrator/accounts/equipments/update/{eid}", data={
            "plate": f"PL{random.randint(100,999)}"
        })

    @task(1)
    def accounts_equipments_show(self):
        self.client.post("/administrator/accounts/equipments/show", data={"unit_id": f"U{random.randint(1000,9999)}"})

    @task(1)
    def accounts_equipments_filter(self):
        self.client.post("/administrator/accounts/equipments/filter", data={"q": "active"})

    @task(1)
    def accounts_components_store(self):
        self.client.post("/administrator/accounts/components/store", data={
            "equipment_id": random.randint(1,200),
            "component_id": random.randint(1,50)
        })

    # Global components endpoints on FleetsController
    @task(1)
    def accounts_list_components(self):
        self.client.get("/administrator/accounts/components")

    @task(1)
    def accounts_assign_components(self):
        self.client.post("/administrator/accounts/components", data={
            "account_id": random.randint(1,50),
            "components": json.dumps([1,2,3])
        })

    # ---------------------------
    # Equipments (generic endpoints under permission)
    # ---------------------------
    @task(1)
    def equipments_list(self):
        self.client.post("/administrator/equipments/list", data={"page": 1})

    @task(1)
    def equipments_create(self):
        self.client.post("/administrator/equipments/create", data={
            "unit_id": f"E{random.randint(1000,9999)}"
        })

    @task(1)
    def equipments_edit(self):
        self.client.post("/administrator/equipments/edit", data={"id": random.randint(1,200)})

    @task(1)
    def equipments_update(self):
        self.client.post("/administrator/equipments/update", data={
            "id": random.randint(1,200),
            "plate": f"PX{random.randint(100,999)}"
        })

    @task(1)
    def equipments_delete(self):
        self.client.post("/administrator/equipments/delete", data={"id": random.randint(1,200)})

    @task(1)
    def equipments_open_add(self):
        self.client.post("/administrator/equipments/openAdd", data={"account_id": random.randint(1,50)})

    @task(1)
    def equipments_filter(self):
        self.client.post("/administrator/equipments/filter", data={"q": "modelX"})

    # ---------------------------
    # Reports (FleetsController and HistoryController)
    # ---------------------------
    @task(1)
    def accounts_history_last(self):
        self.client.post("/administrator/accounts/history/last", data={"account_id": random.randint(1,50)})

    @task(1)
    def accounts_history_all(self):
        self.client.post("/administrator/accounts/history/all", data={"account_id": random.randint(1,50)})

    @task(1)
    def accounts_history_all_export(self):
        sample_id = random.randint(1,500)
        self.client.get(f"/administrator/accounts/history/all/export/{sample_id}")

    @task(1)
    def report_view(self):
        self.client.post("/administrator/report/view", data={"idSample": random.randint(1,500)})

    @task(1)
    def report_graph_view(self):
        self.client.post("/administrator/report/graph/view", data={"idSample": random.randint(1,500)})

    # ---------------------------
    # Production reports (OperatorsLabController)
    # ---------------------------
    @task(1)
    def production_reports_index(self):
        self.client.get("/administrator/production/reports")

    @task(1)
    def production_report_data(self):
        self.client.get("/administrator/production/report/data")



    # ---------------------------
    # Components (ComponentLocationController)
    # ---------------------------
    @task(1)
    def components_index(self):
        self.client.get("/administrator/components")

    @task(1)
    def components_store(self):
        self.client.post("/administrator/components/store", data={
            "name": f"Comp {random.randint(1,10000)}",
            "location": "Bodega A"
        })

    @task(1)
    def components_update(self):
        self.client.post("/administrator/components/update", data={
            "id": random.randint(1,200),
            "name": "Comp Updated"
        })

    @task(1)
    def components_delete(self):
        self.client.post("/administrator/components/delete", data={
            "id": random.randint(1,200)
        })

    # ---------------------------
    # Samples (SamplesController)
    # ---------------------------
    @task(2)
    def samples_index(self):
        self.client.get("/administrator/samples")

    @task(1)
    def samples_send(self):
        self.client.post("/administrator/samples/send", data={
            "sample_id": random.randint(1,500),
            "destination": "lab"
        })

    @task(1)
    def samples_search(self):
        self.client.post("/administrator/samples/search", data={"q": "plate123"})

    @task(1)
    def samples_lubricant(self):
        self.client.post("/administrator/samples/lubricant", data={"lot": "L12345"})

    @task(1)
    def samples_print(self):
        self.client.get(f"/administrator/samples/print/{random.randint(1,500)}")

    @task(1)
    def samples_download(self):
        self.client.get(f"/administrator/samples/download/LOT{random.randint(1,200)}")

    @task(1)
    def samples_autocomplete(self):
        self.client.get("/administrator/autocomplete", params={"term": "PL"})

    # ---------------------------
    # History (HistoryController) - data + list + actions
    # ---------------------------
    @task(1)
    def history_data(self):
        self.client.post("/administrator/history/data", data={
            "start": "2025-01-01",
            "end": "2025-12-31",
            "account_id": random.randint(1,50)
        })

    @task(1)
    def history_allreport(self):
        self.client.get("/administrator/history/allreport")

    @task(1)
    def history_index(self):
        self.client.get("/administrator/history")

    @task(1)
    def history_edit(self):
        self.client.get(f"/administrator/history/edit/{random.randint(1,500)}")

    @task(1)
    def history_update(self):
        self.client.put(f"/administrator/history/update/{random.randint(1,500)}", data={
            "status": "reviewed"
        })

    @task(1)
    def history_show(self):
        self.client.get(f"/administrator/history/show/{random.randint(1,500)}")

    @task(1)
    def history_delete(self):
        self.client.post("/administrator/history/delete", data={"id": random.randint(1,500)})

    @task(1)
    def history_published(self):
        self.client.get("/administrator/history/published")

    @task(1)
    def history_remove(self):
        self.client.get("/administrator/history/remove")

    @task(1)
    def history_samples(self):
        self.client.post("/administrator/history/samples", data={
            "ids": json.dumps([random.randint(1,50), random.randint(51,100)])
        })

    @task(1)
    def history_send_mail(self):
        self.client.post("/administrator/history/sendMail", data={
            "idSample": random.randint(1,500),
            "email": "dest@example.com"
        })

    @task(1)
    def history_send_mail2(self):
        self.client.post("/administrator/history/sendMail2", data={
            "idSample": random.randint(1,500),
            "email": "dest@example.com"
        })

    @task(1)
    def history_send_allreport(self):
        code = f"C{random.randint(1000,9999)}"
        self.client.post(f"/administrator/history/sendAllreport/{code}", data={
            "account_id": random.randint(1,50)
        })

    @task(1)
    def history_download_report(self):
        self.client.post("/administrator/history/downloadReport", data={
            "idSample": random.randint(1,500)
        })

    @task(1)
    def history_report(self):
        self.client.get(f"/administrator/history/report/{random.randint(1,500)}")

    @task(1)
    def history_report_multiple(self):
        self.client.get(f"/administrator/history/report-multiple/{random.randint(1,500)}")

    @task(1)
    def history_report_excel(self):
        self.client.get(f"/administrator/history/report-excel/{random.randint(1,500)}")

    @task(1)
    def history_multiple_reports_view(self):
        # endpoint returns a view rendered from posted data; send small payload
        data = {"data": "<div>test</div>"}
        self.client.post("/administrator/history/multiple-reports", data=data)

 #-------------------------------------------------------------------------------------------------------

    # ---------------------------
    # Import Tests (ImportTestsController)
    # ---------------------------
    @task(1)
    def import_test_get_operario_data(self):
        self.client.get("/administrator/import/test/data")

    @task(1)
    def import_test_index(self):
        self.client.get("/administrator/import/test")

    @task(1)
    def import_test_get_commentary(self):
        self.client.post("/administrator/import/test/get/commentary", data={
            "idSample": random.randint(1, 500)
        })

    @task(1)
    def import_test_post_commentary(self):
        self.client.post("/administrator/import/test/post/commentary", data={
            "idSample": random.randint(1, 500),
            "comment": "Automated comment"
        })

    @task(1)
    def import_test_export_list(self):
        self.client.get("/administrator/import/test/export/list")

    @task(1)
    def import_test_show(self):
        self.client.get("/administrator/import/test/show")

    @task(1)
    def import_test_store_deprecated(self):
        self.client.post("/administrator/import/test/store", data={
            "file": "deprecated.txt",
            "content": "old format"
        })

    @task(1)
    def import_test_save(self):
        self.client.post("/administrator/import/test/save", data={
            "file": "data.txt",
            "content": "sample content"
        })

    @task(1)
    def import_test_info_view(self):
        self.client.post("/administrator/import/test/infoViewTest", data={
            "idSample": random.randint(1, 500)
        })

    @task(1)
    def import_test_update_state(self):
        self.client.post("/administrator/import/test/updateState", data={
            "idSample": random.randint(1, 500),
            "state": "processed"
        })

    @task(1)
    def import_test_reject_lab_test(self):
        self.client.post("/administrator/import/test/rejectLabTest", data={
            "idSample": random.randint(1, 500),
            "reason": "Invalid data"
        })

    @task(1)
    def import_test_apply_rules(self):
        self.client.get("/administrator/import/test/applyRules")

    @task(1)
    def import_test_publish(self):
        self.client.post("/administrator/import/test/publish", data={
            "idSample": random.randint(1, 500)
        })

    @task(1)
    def import_test_delete(self):
        self.client.post("/administrator/import/test/delete", data={
            "idSample": random.randint(1, 500)
        })

    # ---------------------------
    # Parameters (ParametersController)
    # ---------------------------
    @task(1)
    def parameters_index(self):
        self.client.get("/administrator/parameters")

    @task(1)
    def parameters_get_values(self):
        self.client.get(f"/administrator/parameters/getValue/{random.randint(1,50)}")

    # Lubricant Brand
    @task(1)
    def parameters_oil_brand(self):
        self.client.post("/administrator/parameters/oilBrand", data={"q": "Shell"})

    @task(1)
    def parameters_oil_brand_store(self):
        self.client.post("/administrator/parameters/oilBrand/store", data={
            "name": f"Brand {random.randint(1,1000)}"
        })

    @task(1)
    def parameters_oil_brand_edit(self):
        self.client.post("/administrator/parameters/oilBrand/edit", data={"id": random.randint(1,200)})

    @task(1)
    def parameters_oil_brand_update(self):
        self.client.post("/administrator/parameters/oilBrand/update", data={
            "id": random.randint(1,200),
            "name": "Brand Updated"
        })

    @task(1)
    def parameters_oil_brand_show(self):
        self.client.post("/administrator/parameters/oilBrand/show", data={"id": random.randint(1,200)})

    @task(1)
    def parameters_oil_brand_delete(self):
        self.client.post("/administrator/parameters/oilBrand/delete", data={"id": random.randint(1,200)})

    # Lubricant Weight
    @task(1)
    def parameters_oil_weight(self):
        self.client.post("/administrator/parameters/oilWeight", data={"q": "10W40"})

    @task(1)
    def parameters_oil_weight_store(self):
        self.client.post("/administrator/parameters/oilWeight/store", data={
            "weight": "10W40"
        })

    @task(1)
    def parameters_oil_weight_edit(self):
        self.client.post("/administrator/parameters/oilWeight/edit", data={"id": random.randint(1,200)})

    @task(1)
    def parameters_oil_weight_update(self):
        self.client.post("/administrator/parameters/oilWeight/update", data={
            "id": random.randint(1,200),
            "weight": "5W30"
        })

    @task(1)
    def parameters_oil_weight_delete(self):
        self.client.post("/administrator/parameters/oilWeight/delete", data={"id": random.randint(1,200)})

    # Lubricant (general)
    @task(1)
    def parameters_lubricant(self):
        self.client.post("/administrator/parameters/lubricant", data={"q": "LubeX"})

    @task(1)
    def parameters_lubricant_store(self):
        self.client.post("/administrator/parameters/lubricant/store", data={
            "name": f"Lubricant {random.randint(1,1000)}"
        })

    @task(1)
    def parameters_lubricant_edit(self):
        self.client.post("/administrator/parameters/lubricant/edit", data={"id": random.randint(1,200)})

    @task(1)
    def parameters_lubricant_update(self):
        self.client.post("/administrator/parameters/lubricant/update", data={
            "id": random.randint(1,200),
            "name": "Lubricant Updated"
        })

    @task(1)
    def parameters_lubricant_delete(self):
        self.client.post("/administrator/parameters/lubricant/delete", data={"id": random.randint(1,200)})

    # ---------------------------
    # Fleets, Equipments, Components (OptionsController)
    # ---------------------------
    @task(1)
    def get_fleets_for_customer(self):
        self.client.get(f"/administrator/fleets/{random.randint(1,50)}")

    @task(1)
    def options_get_equipments(self):
        self.client.post("/administrator/equipments", data={"fleet_id": random.randint(1,50)})

    @task(1)
    def options_get_components(self):
        self.client.post("/administrator/components", data={"fleet_id": random.randint(1,50)})
 #----------------------------------------------------------------------------------------------------
    @task(1)
    def system_type_list(self):
        self.client.post("/administrator/parameters/systemType", data={"q": "all"})

    @task(1)
    def system_type_store(self):
        self.client.post("/administrator/parameters/systemType/store", data={
            "name": f"SystemType {random.randint(1,1000)}",
            "description": "Auto created"
        })

    @task(1)
    def system_type_edit(self):
        self.client.post("/administrator/parameters/systemType/edit", data={"id": random.randint(1,200)})

    @task(1)
    def system_type_update(self):
        self.client.post("/administrator/parameters/systemType/update", data={
            "id": random.randint(1,200),
            "name": "SystemType Updated"
        })

    @task(1)
    def system_type_show(self):
        self.client.post("/administrator/parameters/systemType/show", data={"id": random.randint(1,200)})

    @task(1)
    def system_type_delete(self):
        self.client.post("/administrator/parameters/systemType/delete", data={"id": random.randint(1,200)})

    # ---------------------------
    # Make (ParametersController)
    # ---------------------------
    @task(1)
    def make_list(self):
        self.client.post("/administrator/parameters/make", data={"q": "all"})

    @task(1)
    def make_store(self):
        self.client.post("/administrator/parameters/make/store", data={
            "name": f"Make {random.randint(1,1000)}"
        })

    @task(1)
    def make_edit(self):
        self.client.post("/administrator/parameters/make/edit", data={"id": random.randint(1,200)})

    @task(1)
    def make_update(self):
        self.client.post("/administrator/parameters/make/update", data={
            "id": random.randint(1,200),
            "name": "Make Updated"
        })

    @task(1)
    def make_show(self):
        self.client.post("/administrator/parameters/make/show", data={"id": random.randint(1,200)})

    @task(1)
    def make_delete(self):
        self.client.post("/administrator/parameters/make/delete", data={"id": random.randint(1,200)})

    # ---------------------------
    # Model (ParametersController)
    # ---------------------------
    @task(1)
    def model_list(self):
        self.client.post("/administrator/parameters/model", data={"q": "all"})

    @task(1)
    def model_store(self):
        self.client.post("/administrator/parameters/model/store", data={
            "name": f"Model {random.randint(1,1000)}",
            "make_id": random.randint(1,50)
        })

    @task(1)
    def model_edit(self):
        self.client.post("/administrator/parameters/model/edit", data={"id": random.randint(1,200)})

    @task(1)
    def model_update(self):
        self.client.post("/administrator/parameters/model/update", data={
            "id": random.randint(1,200),
            "name": "Model Updated"
        })

    @task(1)
    def model_delete(self):
        self.client.post("/administrator/parameters/model/delete", data={"id": random.randint(1,200)})

    # ---------------------------
    # Laboratory Test (LaboratoryTest controller)
    # ---------------------------
    @task(1)
    def laboratory_test_index(self):
        self.client.get("/administrator/laboratoryTest/index")

    @task(1)
    def laboratory_test_history(self):
        self.client.get("/administrator/laboratoryTest/history")

    @task(1)
    def laboratory_test_get_test(self):
        self.client.get("/administrator/laboratoryTest/getTest")

    @task(1)
    def laboratory_test_update(self):
        self.client.put("/administrator/laboratoryTest/update", data={
            "test_id": random.randint(1,500),
            "status": "updated"
        })

    # ---------------------------
    # Templates (TemplatesController)
    # ---------------------------
    @task(1)
    def templates_index(self):
        self.client.get("/administrator/templates")

    @task(1)
    def templates_create(self):
        self.client.get("/administrator/templates/create")

    @task(1)
    def templates_store(self):
        self.client.get("/administrator/templates/store", data={
            "name": f"Template {random.randint(1,1000)}",
            "content": "Auto template content"
        })

    @task(1)
    def templates_show(self):
        self.client.get(f"/administrator/templates/{random.randint(1,200)}")

    @task(1)
    def templates_edit(self):
        self.client.get(f"/administrator/templates/{random.randint(1,200)}/edit")

    @task(1)
    def templates_update(self):
        self.client.put(f"/administrator/templates/{random.randint(1,200)}", data={
            "name": "Template Updated"
        })

    @task(1)
    def templates_delete(self):
        self.client.delete(f"/administrator/templates/{random.randint(1,200)}")

    @task(1)
    def templates_reporter_list(self):
        self.client.get("/administrator/templates/reporter")

    @task(1)
    def templates_reporter_create(self):
        self.client.get("/administrator/templates/reporter/create")

    @task(1)
    def templates_reporter_store(self):
        self.client.post("/administrator/templates/reporter/store", data={
            "name": f"ReporterTemplate {random.randint(1,1000)}"
        })

    @task(1)
    def templates_add_users(self):
        self.client.post("/administrator/templates/addUsers", data={
            "template_id": random.randint(1,200),
            "user_ids": json.dumps([1,2,3])
        })

    @task(1)
    def templates_user_delete(self):
        self.client.post("/administrator/templates/userDelete", data={
            "template_id": random.randint(1,200),
            "user_id": random.randint(1,50)
        })

    @task(1)
    def templates_get_report_download(self):
        self.client.get("/administrator/getReport/download")

    @task(1)
    def templates_customers(self):
        self.client.post("/administrator/templates/customers", data={
            "template_id": random.randint(1,200),
            "customer_ids": json.dumps([1,2])
        })

 #-------------------------------------------

    # OptionsController routes
    @task(2)
    def options_select_model(self):
        self.client.post("/options/model", data={
            "make_id": random.randint(1,50),
            "query": "Model"
        })

    @task(2)
    def options_select_unit_id(self):
        self.client.post("/options/unitId", data={
            "account_id": random.randint(1,50),
            "term": f"U{random.randint(1000,9999)}"
        })

    @task(2)
    def options_get_account_fleets(self):
        self.client.get(f"/options/account/{random.randint(1,50)}")

    @task(1)
    def options_get_countries(self):
        self.client.get("/options/countries")

    @task(1)
    def options_get_cities(self):
        codes = ["05", "08", "11", "15"]  # example country codes; adjust to your data
        self.client.get(f"/options/cities/{random.choice(codes)}")

    @task(1)
    def options_get_model_named(self):
        self.client.post("/options/get-model", data={
            "make_id": random.randint(1,50),
            "model_name": "XSeries"
        })

    @task(1)
    def options_get_customers_all(self):
        self.client.post("/options/customers/all", data={
            "page": 1,
            "per_page": 25
        })

    @task(1)
    def options_customers_unit_id(self):
        self.client.post("/options/customers/unitId", data={
            "customer_id": random.randint(1,50),
            "term": f"U{random.randint(1000,9999)}"
        })

    # Debug / utility routes (closures)
    @task(1)
    def debug_hola(self):
        self.client.get("/hola")

    @task(1)
    def debug_verify_abdiel(self):
        self.client.get("/verifyAbdiel")