from flask import Blueprint, request, jsonify
from datetime import datetime
import re
from dostadmin.db_model import ActivitiesData
from dostadmin import db, db_model, app_logger

api_activity_type_bp = Blueprint("api_activity", __name__)


@api_activity_type_bp.route("/api/activity/types", methods=["GET"])
def get_activity_types():
    state = request.args.get("state")
    if not state:
        return jsonify({"error": "State parameter is required"}), 400

    try:
        types = (
            db.session.query(ActivitiesData.activity_type)
            .filter(ActivitiesData.state == state)
            .distinct()
            .order_by(ActivitiesData.activity_type)
            .all()
        )

        return jsonify([t[0] for t in types if t[0]])

    except Exception as e:
        return jsonify({"error": str(e)}), 500


@api_activity_type_bp.route("/api/activity/dropdown_values", methods=["GET"])
def get_dropdown_values():
    state = request.args.get("state")
    activity_type = request.args.get("activity_type")
    field = request.args.get("field")
    if not state or not activity_type or not field:
        return jsonify({"error": "Missing required parameters"}), 400
    if not hasattr(ActivitiesData, field):
        return jsonify({"error": f"Invalid field: {field}"}), 400
    try:
        field_column = getattr(ActivitiesData, field)
        results = (
            db.session.query(field_column)
            .filter(
                ActivitiesData.state == state,
                ActivitiesData.activity_type == activity_type,
            )
            .filter(field_column.isnot(None))
            .distinct()
            .order_by(field_column)
            .all()
        )

        values = [r[0] for r in results if r[0]]
        return jsonify(values)
    except Exception as e:
        return jsonify({"error": str(e)}), 500


@api_activity_type_bp.route("/api/family_metrics/phones", methods=["GET"])
def get_family_metrics_phones():
    try:
        phones = (
            db_model.FamilyMetrics.query.with_entities(
                db_model.FamilyMetrics.user_phone
            )
            .distinct()
            .all()
        )
        return jsonify([phone[0] for phone in phones if phone[0]])
    except Exception as e:
        app_logger.error(f"Error fetching family metrics phones: {e}")
        return jsonify({"error": str(e)}), 500


@api_activity_type_bp.route("/api/family_metrics/activity_counts", methods=["GET"])
def get_family_metrics_activity_counts():
    try:
        metrics = db_model.FamilyMetrics.query.all()
        counts = {
            metric.user_phone: {
                "mother": metric.mother_count or 0,
                "father": metric.father_count or 0,
                "child": metric.child_count or 0,
            }
            for metric in metrics
        }
        return jsonify(counts)
    except Exception as e:
        app_logger.error(f"Error fetching activity counts: {e}")
        return jsonify({"error": str(e)}), 500


@api_activity_type_bp.route("/api/family_metrics/increase_count", methods=["POST"])
def increase_engagement_count():
    try:
        print("Received request to increase engagement count")
        data = request.get_json()
        user_phone = data.get("user_phone")
        member = data.get("member")
        if (
            not user_phone
            or not re.match(r"^\d{10}$", user_phone)
            or member not in ["mother", "father", "child"]
        ):
            return jsonify({"error": "Invalid phone number or member"}), 400

        family_metric = db_model.FamilyMetrics.query.filter_by(
            user_phone=user_phone
        ).first()
        if family_metric:
            if member == "mother":
                family_metric.mother_count = (family_metric.mother_count or 0) + 1
            elif member == "father":
                family_metric.father_count = (family_metric.father_count or 0) + 1
            elif member == "child":
                family_metric.child_count = (family_metric.child_count or 0) + 1
            family_metric.updated_on = datetime.now()
            db.session.commit()
            return jsonify(
                {
                    "mother": family_metric.mother_count or 0,
                    "father": family_metric.father_count or 0,
                    "child": family_metric.child_count or 0,
                }
            )
        return jsonify({"error": "Family not found"}), 404
    except Exception as e:
        db.session.rollback()
        app_logger.error(f"Error increasing engagement count: {e}")
        return jsonify({"error": str(e)}), 500


@api_activity_type_bp.route("/api/family_metrics/details", methods=["GET"])
def get_family_metrics_details():
    try:
        phone = (request.args.get("phone") or "").strip()
        father_code = (request.args.get("father_code") or "").strip()
        mother_code = (request.args.get("mother_code") or "").strip()

        q = db_model.FamilyMetrics.query

        metric = None
        if phone:
            if not phone.isdigit() or len(phone) != 10:
                return jsonify({"error": "Invalid phone number"}), 400
            metric = q.filter_by(user_phone=phone).first()
        elif father_code:
            print("father_code", father_code)
            metric = q.filter(db_model.FamilyMetrics.father_code == father_code).first()
            if not metric:
                metric = q.filter(
                    db_model.FamilyMetrics.father_code.ilike(f"%{father_code}%")
                ).first()
        elif mother_code:
            metric = q.filter(db_model.FamilyMetrics.mother_code == mother_code).first()
            if not metric:
                metric = q.filter(
                    db_model.FamilyMetrics.mother_code.ilike(f"%{mother_code}%")
                ).first()
        else:
            return jsonify({"error": "No identifier provided"}), 400

        if metric:
            return jsonify(
                {
                    "mother": metric.mother_count or 0,
                    "father": metric.father_count or 0,
                    "child": metric.child_count or 0,
                    "mother_name": metric.mother_name or "",
                    "father_name": metric.father_name or "",
                    "child_name": metric.child_name or "",
                }
            )

        return jsonify(
            {
                "mother": 0,
                "father": 0,
                "child": 0,
                "mother_name": "",
                "father_name": "",
                "child_name": "",
            }
        )
    except Exception as e:
        app_logger.error(f"Error fetching family metrics details: {e}")
        return jsonify({"error": str(e)}), 500