# Example Odoo model extension for Xero integration
from odoo import models, fields, api

class AccountMove(models.Model):
    _inherit = 'account.move'
    
    xero_invoice_id = fields.Char('Xero Invoice ID', copy=False)
    xero_sync_status = fields.Selection([
        ('pending', 'Pending'),
        ('synced', 'Synced'),
        ('failed', 'Failed')
    ], default='pending')
    
    def sync_to_xero(self):
        """Push Odoo invoice to Xero via API"""
        xero_client = self.env['xero.api.client'].get_client()
        
        invoice_data = {
            'Type': 'ACCREC',
            'Contact': {'ContactID': self.partner_id.xero_contact_id},
            'LineItems': [{
                'Description': line.name,
                'Quantity': line.quantity,
                'UnitAmount': line.price_unit,
                'AccountCode': line.account_id.code
            } for line in self.invoice_line_ids]
        }
        
        response = xero_client.invoices.put(invoice_data)
        if response:
            self.xero_invoice_id = response['InvoiceID']
            self.xero_sync_status = 'synced'

# Deduplication logic for contact synchronization
def sync_contacts_to_xero(self):
    contacts_to_sync = self.env['res.partner'].search([
        ('customer_rank', '>', 0),
        ('xero_contact_id', '=', False),
        ('active', '=', True)
    ])
    
    for contact in contacts_to_sync:
        # Check for existing Xero contact by email
        existing_xero_contact = xero_client.contacts.filter(
            f"EmailAddress==\"{contact.email}\""
        )
        
        if existing_xero_contact:
            contact.xero_contact_id = existing_xero_contact[0]['ContactID']
        else:
            # Create new contact in Xero
            contact_data = {
                'Name': contact.name,
                'EmailAddress': contact.email,
                'Addresses': [{
                    'AddressType': 'STREET',
                    'AddressLine1': contact.street,
                    'City': contact.city,
                    'PostalCode': contact.zip
                }]
            }
            response = xero_client.contacts.put(contact_data)
            contact.xero_contact_id = response['ContactID']

class InvoiceSyncService:
    def __init__(self, odoo_env, xero_client):
        self.odoo = odoo_env
        self.xero = xero_client
    
    def sync_invoice(self, odoo_invoice):
        """Handle complete invoice synchronization"""
        
        # Map Odoo tax to Xero tax rate
        tax_mapping = self._map_tax_rates(odoo_invoice)
        
        # Handle currency conversion if needed
        if odoo_invoice.currency_id != odoo_invoice.company_id.currency_id:
            exchange_rate = self._get_exchange_rate(
                odoo_invoice.currency_id,
                odoo_invoice.date_invoice
            )
        
        # Build Xero-compatible invoice structure
        xero_invoice = {
            'InvoiceNumber': odoo_invoice.name,
            'Reference': odoo_invoice.ref,
            'CurrencyCode': odoo_invoice.currency_id.name,
            'Status': 'AUTHORISED' if odoo_invoice.state == 'posted' else 'DRAFT',
            'LineItems': self._build_line_items(odoo_invoice, tax_mapping)
        }
        
        return self.xero.invoices.put(xero_invoice)

class XeroAPIClient:
    def __init__(self, client_id, client_secret, redirect_uri):
        self.client_id = client_id
        self.client_secret = client_secret
        self.redirect_uri = redirect_uri
        self.token_url = "https://identity.xero.com/connect/token"
        
    def get_access_token(self, refresh_token=None):
        """Obtain or refresh access token"""
        if refresh_token:
            data = {
                'grant_type': 'refresh_token',
                'refresh_token': refresh_token
            }
        else:
            data = {'grant_type': 'authorization_code'}
            
        response = requests.post(
            self.token_url,
            data=data,
            auth=(self.client_id, self.client_secret),
            headers={'Content-Type': 'application/x-www-form-urlencoded'}
        )
        
        return response.json()

class ResilientAPIClient:
    MAX_RETRIES = 3
    RETRY_DELAY = 5  # seconds
    
    def execute_with_retry(self, api_call, *args, **kwargs):
        """Execute API call with exponential backoff retry"""
        for attempt in range(self.MAX_RETRIES):
            try:
                return api_call(*args, **kwargs)
            except (requests.exceptions.Timeout, 
                    requests.exceptions.ConnectionError) as e:
                if attempt == self.MAX_RETRIES - 1:
                    raise
                time.sleep(self.RETRY_DELAY * (2 ** attempt))
            except XeroRateLimitError:
                time.sleep(60)  # Wait for rate limit reset
                continue

def batch_sync_invoices(self, invoice_ids, batch_size=50):
    """Process invoices in batches to avoid API limits"""
    invoices = self.env['account.move'].browse(invoice_ids)
    
    for i in range(0, len(invoices), batch_size):
        batch = invoices[i:i + batch_size]
        
        # Create batch payload
        batch_payload = {
            'Invoices': [
                self._prepare_invoice_data(inv) 
                for inv in batch
            ]
        }
        
        # Send batch to Xero
        response = self.xero_client.invoices.put(batch_payload)
        
        # Update sync status
        self._update_sync_status(batch, response)
        
        # Respect API rate limits
        time.sleep(1)

-- Indexes for integration performance
CREATE INDEX idx_xero_sync_status 
ON account_move (xero_sync_status) 
WHERE xero_sync_status IN ('pending', 'failed');

CREATE INDEX idx_xero_contact_id 
ON res_partner (xero_contact_id) 
WHERE xero_contact_id IS NOT NULL;

-- Materialized view for sync reporting
CREATE MATERIALIZED VIEW mv_sync_metrics AS
SELECT 
    DATE(create_date) as sync_date,
    COUNT(*) as total_records,
    COUNT(CASE WHEN xero_sync_status = 'synced' THEN 1 END) as synced,
    COUNT(CASE WHEN xero_sync_status = 'failed' THEN 1 END) as failed
FROM account_move
GROUP BY DATE(create_date);

# Docker Compose configuration for integration services
version: '3.8'

services:
  odoo:
    image: odoo:16.0
    depends_on:
      - db
      - redis
    environment:
      - HOST=db
      - USER=odoo
      - PASSWORD=${DB_PASSWORD}
    volumes:
      - ./addons:/mnt/extra-addons
      - ./config:/etc/odoo
    deploy:
      replicas: 3
      
  integration-worker:
    build: ./integration
    environment:
      - REDIS_URL=redis://redis:6379
      - ODOO_URL=http://odoo:8069
      - DATABASE_NAME=${DB_NAME}
    depends_on:
      - redis
      - odoo
    deploy:
      replicas: 2
      
  redis:
    image: redis:alpine
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
      
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=${DB_NAME}
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_USER=odoo
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  postgres-data:
  redis-data:

# Integration health checks
class IntegrationMonitor:
    def check_health(self):
        checks = {
            'api_connectivity': self._check_xero_api(),
            'sync_queue_size': self._get_queue_size(),
            'error_rate': self._calculate_error_rate(),
            'latency': self._measure_sync_latency()
        }
        
        # Alert if any check fails
        for check_name, status in checks.items():
            if not status['healthy']:
                self._send_alert(
                    f"Integration check failed: {check_name}",
                    status['details']
                )

<!-- Odoo automated action for invoice synchronization -->
<record id="action_sync_invoice_to_xero" model="ir.actions.server">
    <field name="name">Sync Invoice to Xero</field>
    <field name="model_id" ref="account.model_account_move"/>
    <field name="state">code</field>
    <field name="code">
        if record.state == 'posted' and not record.xero_invoice_id:
            env['xero.integration'].sync_invoice(record.id)
    </field>
    <field name="binding_model_id" ref="account.model_account_move"/>
    <field name="binding_type">action</field>
</record>

class MultiCompanyXeroIntegration:
    def get_xero_client_for_company(self, company_id):
        """Retrieve appropriate Xero client for company"""
        company = self.env['res.company'].browse(company_id)
        
        # Each company can have its own Xero credentials
        credentials = self.env['xero.company.config'].search([
            ('company_id', '=', company_id),
            ('active', '=', True)
        ])
        
        if not credentials:
            # Fall back to default configuration
            credentials = self.env['xero.company.config'].search([
                ('is_default', '=', True),
                ('active', '=', True)
            ])
        
        return XeroAPIClient(
            credentials.client_id,
            credentials.client_secret,
            credentials.redirect_uri
        )

class ReconciliationService:
    def reconcile_invoices(self, date_from, date_to):
        """Compare Odoo and Xero invoices for given period"""
        
        # Get invoices from Odoo
        odoo_invoices = self.env['account.move'].search([
            ('invoice_date', '>=', date_from),
            ('invoice_date', '<=', date_to),
            ('move_type', 'in', ['out_invoice', 'out_refund'])
        ])
        
        # Get invoices from Xero
        xero_invoices = self.xero_client.invoices.filter(
            f"Date >= DateTime({date_from}) AND Date <= DateTime({date_to})"
        )
        
        # Create mapping by invoice number
        odoo_map = {inv.name: inv for inv in odoo_invoices}
        xero_map = {inv['InvoiceNumber']: inv for inv in xero_invoices}
        
        # Identify discrepancies
        discrepancies = []
        for invoice_number in set(odoo_map.keys()) | set(xero_map.keys()):
            odoo_inv = odoo_map.get(invoice_number)
            xero_inv = xero_map.get(invoice_number)
            
            if not odoo_inv or not xero_inv:
                discrepancies.append({
                    'invoice_number': invoice_number,
                    'issue': 'Missing in one system',
                    'odoo_amount': odoo_inv.amount_total if odoo_inv else None,
                    'xero_amount': xero_inv['Total'] if xero_inv else None
                })
            elif abs(odoo_inv.amount_total - float(xero_inv['Total'])) > 0.01:
                discrepancies.append({
                    'invoice_number': invoice_number,
                    'issue': 'Amount mismatch',
                    'odoo_amount': odoo_inv.amount_total,
                    'xero_amount': float(xero_inv['Total'])
                })
        
        return discrepancies

class IntegrationAuditLogger:
    def log_sync_operation(self, operation, record_id, status, details=None):
        """Log all integration operations"""
        self.env['xero.sync.audit'].create({
            'timestamp': fields.Datetime.now(),
            'operation': operation,
            'model': self._get_model_name(record_id),
            'record_id': record_id,
            'status': status,
            'details': details or {},
            'user_id': self.env.uid
        })

class TestXeroIntegration(TransactionCase):
    def setUp(self):
        super().setUp()
        self.integration = self.env['xero.integration']
        
    def test_invoice_synchronization(self):
        """Test complete invoice sync flow"""
        # Create test invoice in Odoo
        invoice = self.env['account.move'].create({
            'move_type': 'out_invoice',
            'partner_id': self.partner.id,
            'invoice_line_ids': [(0, 0, {
                'name': 'Test Product',
                'quantity': 2,
                'price_unit': 100,
                'tax_ids': [(6, 0, [self.tax.id])]
            })]
        })
        
        # Post invoice
        invoice.action_post()
        
        # Sync to Xero
        result = self.integration.sync_invoice(invoice.id)
        
        # Verify sync
        self.assertEqual(invoice.xero_sync_status, 'synced')
        self.assertIsNotNone(invoice.xero_invoice_id)
        
        # Verify data in Xero
        xero_invoice = self.xero_client.invoices.get(invoice.xero_invoice_id)
        self.assertEqual(float(xero_invoice['Total']), 240.0)  # 200 + 40 tax

class CachedXeroClient:
    def __init__(self, xero_client, redis_client, ttl=3600):
        self.xero = xero_client
        self.redis = redis_client
        self.ttl = ttl
    
    def get_contact(self, contact_id):
        cache_key = f"xero:contact:{contact_id}"
        
        # Try cache first
        cached = self.redis.get(cache_key)
        if cached:
            return json.loads(cached)
        
        # Fetch from Xero
        contact = self.xero.contacts.get(contact_id)
        
        # Cache result
        self.redis.setex(cache_key, self.ttl, json.dumps(contact))
        
        return contact

def get_pending_sync_records(self, limit=1000):
    """Efficient query for pending sync records"""
    query = """
    SELECT id, name, amount_total, partner_id
    FROM account_move
    WHERE xero_sync_status = 'pending'
      AND state = 'posted'
      AND move_type IN ('out_invoice', 'out_refund')
    ORDER BY create_date
    LIMIT %s
    FOR UPDATE SKIP LOCKED
    """
    
    self.env.cr.execute(query, (limit,))
    return self.env.cr.dictfetchall()

class VersionAwareXeroClient:
    API_VERSIONS = {
        '2023-03-01': {'endpoints': {...}, 'deprecated': False},
        '2022-12-01': {'endpoints': {...}, 'deprecated': True}
    }
    
    def __init__(self, base_version='2023-03-01'):
        self.base_version = base_version
        self.headers = {
            'xero-tenant-id': self.tenant_id,
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        }
        
    def make_request(self, endpoint, method='GET', data=None):
        """Make version-aware API request"""
        url = f"https://api.xero.com/api.xro/2.0/{endpoint}"
        
        # Add version-specific headers if needed
        if self.requires_version_header(endpoint):
            self.headers['Xero-API-Version'] = self.base_version
        
        response = requests.request(
            method,
            url,
            headers=self.headers,
            json=data
        )
        
        # Handle version deprecation warnings
        if 'Deprecation' in response.headers:
            self.log_deprecation_warning(response.headers['Deprecation'])
        
        return response