import json
import logging

from odoo import http
from odoo.http import request

_logger = logging.getLogger(__name__)


class FusionAccountingChatController(http.Controller):

    @http.route('/fusion_accounting/session/create', type='jsonrpc', auth='user')
    def create_session(self, context_domain=None, **kwargs):
        session = request.env['fusion.accounting.session'].create({
            'user_id': request.env.user.id,
            'company_id': request.env.company.id,
            'context_domain': context_domain,
        })
        return {'session_id': session.id, 'name': session.name}

    @http.route('/fusion_accounting/session/close', type='jsonrpc', auth='user')
    def close_session(self, session_id, **kwargs):
        session = request.env['fusion.accounting.session'].browse(int(session_id))
        if session.exists() and session.state == 'active':
            session.action_close_session()
        return {'status': 'closed'}

    @http.route('/fusion_accounting/chat', type='jsonrpc', auth='user')
    def chat(self, session_id, message, context=None, **kwargs):
        if not message:
            return {'error': 'Message is required'}
        agent = request.env['fusion.accounting.agent']
        result = agent.chat(int(session_id), message, context=context)
        return result

    @http.route('/fusion_accounting/approve', type='jsonrpc', auth='user')
    def approve_action(self, match_history_id, **kwargs):
        if not request.env.user.has_group('fusion_accounting.group_fusion_accounting_manager'):
            return {'error': 'Insufficient permissions to approve actions'}
        agent = request.env['fusion.accounting.agent']
        result = agent.approve_action(int(match_history_id))
        return result

    @http.route('/fusion_accounting/reject', type='jsonrpc', auth='user')
    def reject_action(self, match_history_id, reason='', **kwargs):
        if not request.env.user.has_group('fusion_accounting.group_fusion_accounting_manager'):
            return {'error': 'Insufficient permissions to reject actions'}
        agent = request.env['fusion.accounting.agent']
        result = agent.reject_action(int(match_history_id), reason)
        return result

    @http.route('/fusion_accounting/dashboard/data', type='jsonrpc', auth='user')
    def dashboard_data(self, **kwargs):
        dashboard = request.env['fusion.accounting.dashboard'].new({
            'company_id': request.env.company.id,
        })
        return {
            'bank_recon': {'count': dashboard.bank_recon_count, 'amount': dashboard.bank_recon_amount},
            'ar': {'total': dashboard.ar_total, 'overdue_count': dashboard.ar_overdue_count},
            'ap': {'total': dashboard.ap_total, 'due_this_week': dashboard.ap_due_this_week},
            'hst': {'balance': dashboard.hst_balance},
            'audit': {'score': dashboard.audit_score, 'flags': dashboard.audit_flag_count},
            'month_end': {'status': dashboard.month_end_status, 'open_items': dashboard.month_end_open_items},
        }

    @http.route('/fusion_accounting/approve_all', type='jsonrpc', auth='user')
    def approve_all(self, match_history_ids, **kwargs):
        if not request.env.user.has_group('fusion_accounting.group_fusion_accounting_manager'):
            return {'error': 'Insufficient permissions to approve actions'}
        agent = request.env['fusion.accounting.agent']
        results = []
        for mid in match_history_ids:
            try:
                result = agent.approve_action(int(mid))
                results.append({'id': mid, 'status': 'approved', 'result': result})
            except Exception as e:
                results.append({'id': mid, 'status': 'error', 'error': str(e)})
        return {'results': results}

    @http.route('/fusion_accounting/reject_all', type='jsonrpc', auth='user')
    def reject_all(self, match_history_ids, reason='', **kwargs):
        if not request.env.user.has_group('fusion_accounting.group_fusion_accounting_manager'):
            return {'error': 'Insufficient permissions to reject actions'}
        agent = request.env['fusion.accounting.agent']
        results = []
        for mid in match_history_ids:
            try:
                result = agent.reject_action(int(mid), reason)
                results.append({'id': mid, 'status': 'rejected'})
            except Exception as e:
                results.append({'id': mid, 'status': 'error', 'error': str(e)})
        return {'results': results}

    @http.route('/fusion_accounting/session/latest', type='jsonrpc', auth='user')
    def session_latest(self, **kwargs):
        session = request.env['fusion.accounting.session'].search([
            ('user_id', '=', request.env.user.id),
            ('state', '=', 'active'),
        ], limit=1, order='create_date desc')
        if not session:
            return {'session_id': None, 'messages': [], 'name': None}
        messages = json.loads(session.message_ids_json or '[]')
        display_messages = []
        for msg in messages:
            if isinstance(msg.get('content'), str) and msg['content'].strip():
                display_messages.append(msg)
            elif isinstance(msg.get('content'), list):
                for block in msg['content']:
                    if isinstance(block, dict) and block.get('type') == 'text' and block['text'].strip():
                        display_messages.append({'role': msg['role'], 'content': block['text']})
        return {
            'session_id': session.id,
            'messages': display_messages,
            'name': session.name,
        }

    @http.route('/fusion_accounting/session/history', type='jsonrpc', auth='user')
    def session_history(self, session_id, **kwargs):
        session = request.env['fusion.accounting.session'].browse(int(session_id))
        if not session.exists():
            return {'error': 'Session not found'}
        return {
            'messages': json.loads(session.message_ids_json or '[]'),
            'session_id': session.id,
            'state': session.state,
        }