"""Single source of truth for loan field types, ranges and allowed values.

Used by the loan API (create/update) and the CSV import so every write path
applies identical rules. Returns cleaned values plus human-readable errors;
never raises for bad user input.
"""
from datetime import date, datetime

STATUSES = ('Loan Open', 'Underwriting', 'Approved', 'Clear to Close', 'Docs Out',
            'Funded', 'Cancelled', 'Withdrawn')
ACTIVE_STATUSES = STATUSES[:5]

TEXT, MONEY, NUMBER, INTEGER, DATE, STATUS = 'text', 'money', 'number', 'integer', 'date', 'status'

# field -> (kind, min, max)
FIELDS = {
    'loan_number': (TEXT, 1, 40),
    'borrower_last': (TEXT, 0, 80),
    'borrower_first': (TEXT, 0, 80),
    'loan_program': (TEXT, 0, 80),
    'loan_channel': (TEXT, 0, 40),
    'loan_status': (STATUS, None, None),
    'loan_purpose': (TEXT, 0, 60),
    'property_purpose': (TEXT, 0, 60),
    'loan_amount': (MONEY, 0, 100_000_000),
    'note_rate': (NUMBER, 0, 25),
    'ltv': (NUMBER, 0, 200),
    'credit_score': (INTEGER, 300, 850),
    'broker_company': (TEXT, 0, 120),
    'account_executive': (TEXT, 0, 80),
    'underwriter': (TEXT, 0, 80),
    'processor': (TEXT, 0, 80),
    'registered_date': (DATE, None, None),
    'underwriting_date': (DATE, None, None),
    'approved_date': (DATE, None, None),
    'clear_to_close_date': (DATE, None, None),
    'docs_out_date': (DATE, None, None),
    'docs_back_date': (DATE, None, None),
    'scheduled_funding': (DATE, None, None),
    'funded_date': (DATE, None, None),
    'rate_locked_date': (DATE, None, None),
    'investor_name': (TEXT, 0, 120),
    'broker_lock_price': (NUMBER, 0, 200),
    'investor_lock_price': (NUMBER, 0, 200),
    'gross_profit': (MONEY, -10_000_000, 10_000_000),
    'net_profit': (MONEY, -10_000_000, 10_000_000),
}
EDITABLE = frozenset(FIELDS) - {'loan_number'}
DATE_FORMATS = ('%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', '%Y/%m/%d')
MIN_DATE, MAX_DATE = date(1990, 1, 1), date(2100, 12, 31)


def parse_date(value):
    """Return ISO date text, None for blank, or raise ValueError for unparseable input."""
    if value is None or (isinstance(value, str) and not value.strip()):
        return None
    if isinstance(value, datetime):
        value = value.date()
    if isinstance(value, date):
        parsed = value
    else:
        text = str(value).strip()[:10] if 'T' in str(value) else str(value).strip()
        for fmt in DATE_FORMATS:
            try:
                parsed = datetime.strptime(text, fmt).date()
                break
            except ValueError:
                continue
        else:
            raise ValueError(f'unrecognized date {str(value)[:20]!r}')
    if not MIN_DATE <= parsed <= MAX_DATE:
        raise ValueError(f'date {parsed.isoformat()} is out of range')
    return parsed.isoformat()


def parse_number(value, money=False):
    if value is None or (isinstance(value, str) and not value.strip()):
        return None
    if isinstance(value, bool):
        raise ValueError('expected a number')
    if isinstance(value, (int, float)):
        return float(value)
    text = str(value).strip().replace(',', '')
    if money:
        text = text.replace('$', '')
    negative = text.startswith('(') and text.endswith(')')
    if negative:
        text = text[1:-1]
    text = text.rstrip('%')
    try:
        number = float(text)
    except ValueError:
        raise ValueError(f'expected a number, got {str(value)[:20]!r}') from None
    return -number if negative else number


def clean_value(field, value):
    kind, low, high = FIELDS[field]
    if kind == TEXT:
        if value is None:
            return None
        text = str(value).strip()
        if len(text) > high:
            raise ValueError(f'longer than {high} characters')
        if low and len(text) < low:
            raise ValueError('is required')
        return text or None
    if kind == STATUS:
        if value is None or str(value).strip() == '':
            return None
        text = str(value).strip()
        match = next((s for s in STATUSES if s.lower() == text.lower()), None)
        if match is None:
            raise ValueError(f'unknown status {text[:30]!r}')
        return match
    if kind == DATE:
        return parse_date(value)
    number = parse_number(value, money=(kind == MONEY))
    if number is None:
        return None
    if kind == INTEGER:
        if number != int(number):
            raise ValueError('expected a whole number')
        number = int(number)
    if (low is not None and number < low) or (high is not None and number > high):
        raise ValueError(f'must be between {low:,} and {high:,}')
    return number


def cross_field_errors(record):
    """Business rules spanning several fields (only checks fields that are present)."""
    errors = []
    registered, funded = record.get('registered_date'), record.get('funded_date')
    if registered and funded and funded < registered:
        errors.append('funded_date is before registered_date')
    if record.get('loan_status') == 'Funded' and 'funded_date' in record and not funded:
        errors.append('Funded status requires funded_date')
    if record.get('loan_status') in ACTIVE_STATUSES and funded:
        errors.append(f"status {record['loan_status']!r} conflicts with a funded_date")
    return errors


def validate(data, *, require_loan_number=False, allowed=None):
    """Validate a mapping of field -> raw value. Returns (clean, errors)."""
    allowed = FIELDS.keys() if allowed is None else allowed
    clean, errors = {}, []
    if not isinstance(data, dict):
        return {}, ['payload must be a JSON object']
    unknown = sorted(k for k in data if k not in allowed)
    if unknown:
        errors.append('unknown or non-editable fields: ' + ', '.join(unknown[:8]))
    for field, raw in data.items():
        if field not in allowed:
            continue
        try:
            clean[field] = clean_value(field, raw)
        except (ValueError, TypeError) as exc:
            errors.append(f'{field}: {exc}')
    if require_loan_number and not clean.get('loan_number'):
        errors.append('loan_number: is required')
    if not errors:
        errors.extend(cross_field_errors(clean))
    return clean, errors
