"""Identity administration and per-user profiles."""
import os
import re
import sqlite3
import sys
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
from flask import Blueprint, render_template, request, jsonify, session
from werkzeug.security import generate_password_hash, check_password_hash
from core import get_db, login_required, roles_required, current_user, audit_event

bp = Blueprint('users', __name__)
ROLES = {'admin', 'analyst', 'viewer'}
USER_FIELDS = 'id, username, display_name, email, job_title, timezone, role, is_active, created_at, last_login_at'


def valid_email(value):
    return value is None or (len(value) <= 160 and re.fullmatch(r'[^\s@]+@[^\s@]+\.[^\s@]+', value))


@bp.route('/users')
@roles_required('admin')
def index():
    conn = get_db()
    users = [dict(row) for row in conn.execute(f'SELECT {USER_FIELDS} FROM users ORDER BY id')]
    conn.close()
    return render_template('users.html', accounts=users, roles=sorted(ROLES))


@bp.route('/api/users')
@roles_required('admin')
def list_users():
    conn = get_db()
    rows = conn.execute(f'SELECT {USER_FIELDS} FROM users ORDER BY id').fetchall()
    conn.close()
    return jsonify([dict(row) for row in rows])


@bp.route('/api/users', methods=['POST'])
@roles_required('admin')
def create_user():
    data = request.get_json(silent=True) or {}
    username = str(data.get('username', '')).strip()
    name = str(data.get('display_name', '')).strip()
    email = str(data.get('email', '')).strip().lower() or None
    password = str(data.get('password', ''))
    role = data.get('role', 'viewer')
    if not re.fullmatch(r'[A-Za-z0-9_.-]{3,40}', username) or not (2 <= len(name) <= 80):
        return jsonify(error='Username must be 3-40 characters; display name 2-80.'), 400
    if not valid_email(email) or len(password) < 12 or role not in ROLES:
        return jsonify(error='Provide a valid email, 12+ character password and valid role.'), 400
    conn = get_db()
    try:
        cur = conn.execute('INSERT INTO users (username, password_hash, role, display_name, email, is_active) VALUES (?,?,?,?,?,1)',
                           (username, generate_password_hash(password), role, name, email))
        audit_event('user.created', 'identity', username, f'role={role}', conn)
        conn.commit()
        return jsonify(id=cur.lastrowid, message='User created'), 201
    except sqlite3.IntegrityError:
        conn.rollback()
        return jsonify(error='Username or email already exists.'), 409
    finally:
        conn.close()


@bp.route('/api/users/<int:user_id>', methods=['PATCH'])
@roles_required('admin')
def update_user(user_id):
    data = request.get_json(silent=True) or {}
    if not data or any(k not in ('role', 'is_active') for k in data):
        return jsonify(error='Only role and active status can be changed here.'), 400
    if 'role' in data and data['role'] not in ROLES:
        return jsonify(error='Unknown role.'), 400
    if 'is_active' in data and type(data['is_active']) is not bool:
        return jsonify(error='is_active must be boolean.'), 400
    conn = get_db()
    current = conn.execute('SELECT username, role, is_active FROM users WHERE id=?', (user_id,)).fetchone()
    if not current:
        conn.close()
        return jsonify(error='User not found.'), 404
    role = data.get('role', current['role'])
    active = int(data.get('is_active', bool(current['is_active'])))
    if user_id == session['user_id'] and (role != 'admin' or not active):
        conn.close()
        return jsonify(error='You cannot remove your own administrator access.'), 400
    if current['role'] == 'admin' and (role != 'admin' or not active):
        admins = conn.execute("SELECT COUNT(*) FROM users WHERE role='admin' AND is_active=1").fetchone()[0]
        if admins <= 1:
            conn.close()
            return jsonify(error='At least one active administrator is required.'), 400
    conn.execute('UPDATE users SET role=?, is_active=? WHERE id=?', (role, active, user_id))
    audit_event('user.access_changed', 'identity', current['username'],
                f"role:{current['role']}->{role};active:{current['is_active']}->{active}", conn)
    conn.commit()
    conn.close()
    return jsonify(message='Access updated')


@bp.route('/profile')
@login_required
def profile():
    return render_template('profile.html', account=current_user())


@bp.route('/api/profile', methods=['PATCH'])
@login_required
def update_profile():
    data = request.get_json(silent=True) or {}
    allowed = {'display_name', 'email', 'job_title', 'timezone'}
    if not data or any(key not in allowed for key in data):
        return jsonify(error='Unknown profile field.'), 400
    updates = {}
    for key, value in data.items():
        value = str(value or '').strip()
        if len(value) > (160 if key == 'email' else 80):
            return jsonify(error=f'{key} exceeds length limit.'), 400
        updates[key] = value or None
    if 'email' in updates and not valid_email(updates['email']):
        return jsonify(error='Invalid email address.'), 400
    if 'display_name' in updates and not updates['display_name']:
        return jsonify(error='Display name is required.'), 400
    conn = get_db()
    try:
        assignments = ', '.join(f'{field}=?' for field in updates)
        conn.execute(f'UPDATE users SET {assignments} WHERE id=?', [*updates.values(), session['user_id']])
        audit_event('profile.updated', 'identity', current_user()['username'], 'fields=' + ','.join(updates), conn)
        conn.commit()
    except sqlite3.IntegrityError:
        conn.rollback()
        return jsonify(error='Email is in use.'), 409
    finally:
        conn.close()
    return jsonify(message='Profile updated')


@bp.route('/api/profile/password', methods=['POST'])
@login_required
def change_password():
    data = request.get_json(silent=True) or {}
    old, new = data.get('current_password', ''), data.get('new_password', '')
    if not isinstance(old, str) or not isinstance(new, str) or len(new) < 12 or old == new:
        return jsonify(error='Choose a different password of at least 12 characters.'), 400
    conn = get_db()
    row = conn.execute('SELECT password_hash FROM users WHERE id=?', (session['user_id'],)).fetchone()
    if not row or not check_password_hash(row['password_hash'], old):
        conn.close()
        return jsonify(error='Current password is incorrect.'), 403
    conn.execute('UPDATE users SET password_hash=? WHERE id=?', (generate_password_hash(new), session['user_id']))
    audit_event('password.changed', 'identity', current_user()['username'], 'self-service change', conn)
    conn.commit()
    conn.close()
    return jsonify(message='Password updated')


@bp.route('/api/users/<int:user_id>/reset-password', methods=['POST'])
@roles_required('admin')
def admin_reset_password(user_id):
    """Administrator sets a temporary password (e.g. account recovery); clears any lockout."""
    data = request.get_json(silent=True) or {}
    password = data.get('password', '')
    if not isinstance(password, str) or len(password) < 12:
        return jsonify(error='Temporary password must be at least 12 characters.'), 400
    conn = get_db()
    try:
        user = conn.execute('SELECT username FROM users WHERE id=?', (user_id,)).fetchone()
        if not user:
            return jsonify(error='User not found.'), 404
        conn.execute('UPDATE users SET password_hash=? WHERE id=?', (generate_password_hash(password), user_id))
        conn.execute("INSERT INTO login_attempts (username, remote_addr, success) VALUES (?, 'admin-reset', 1)",
                     (user['username'],))
        audit_event('password.reset_by_admin', 'identity', user['username'], 'temporary password issued', conn)
        conn.commit()
        return jsonify(message='Temporary password set. Ask the user to change it after signing in.')
    finally:
        conn.close()


@bp.route('/api/users/<int:user_id>/unlock', methods=['POST'])
@roles_required('admin')
def admin_unlock(user_id):
    """Clear a sign-in lockout without changing the password."""
    conn = get_db()
    try:
        user = conn.execute('SELECT username FROM users WHERE id=?', (user_id,)).fetchone()
        if not user:
            return jsonify(error='User not found.'), 404
        conn.execute("INSERT INTO login_attempts (username, remote_addr, success) VALUES (?, 'admin-unlock', 1)",
                     (user['username'],))
        audit_event('user.unlocked', 'identity', user['username'], 'lockout cleared', conn)
        conn.commit()
        return jsonify(message='Sign-in lockout cleared.')
    finally:
        conn.close()
