import csv
import io
import json

from rest_framework import viewsets, status
from rest_framework.decorators import api_view
from rest_framework.response import Response

from .models import (
    Contact,
    Relation,
    NetworkMap,
    NetworkMapMembership,
    RELATION_TYPES,
    LIFE_SPHERES,
    NETWORK_CIRCLES,
    INTERACTION_INTENSITY,
)
from .serializers import (
    ContactSerializer,
    RelationSerializer,
    NetworkMapSerializer,
    NetworkMapMembershipSerializer,
)


class ContactViewSet(viewsets.ModelViewSet):
    queryset = Contact.objects.all()
    serializer_class = ContactSerializer

    def get_queryset(self):
        qs = super().get_queryset()
        q = self.request.query_params.get('search', '')
        if q:
            qs = qs.filter(name__icontains=q)
        return qs


class RelationViewSet(viewsets.ModelViewSet):
    queryset = Relation.objects.select_related('source', 'target').all()
    serializer_class = RelationSerializer


class NetworkMapViewSet(viewsets.ModelViewSet):
    queryset = NetworkMap.objects.all()
    serializer_class = NetworkMapSerializer


class NetworkMapMembershipViewSet(viewsets.ModelViewSet):
    serializer_class = NetworkMapMembershipSerializer

    def get_queryset(self):
        map_id = self.kwargs.get('map_pk')
        return NetworkMapMembership.objects.filter(
            map_id=map_id
        ).select_related('contact', 'map')

    def perform_create(self, serializer):
        map_id = self.kwargs.get('map_pk')
        serializer.save(map_id=map_id)


def _node_from_membership(membership):
    contact = membership.contact
    return {
        'id': contact.id,
        'label': contact.name,
        'title': '\n'.join(filter(None, [contact.organization, contact.position, contact.email])),
        'group': contact.organization or 'default',
        'life_sphere': membership.life_sphere,
        'network_circle': membership.network_circle,
        'importance': membership.importance,
        'map_angle': membership.map_angle,
        'map_radius_ratio': membership.map_radius_ratio,
        'membership_id': membership.id,
    }


def _edge_from_relation(r):
    return {
        'id': r.id,
        'from': r.source_id,
        'to': r.target_id,
        'label': r.get_relation_type_display(),
        'title': r.description or r.get_relation_type_display(),
        'relation_type': r.relation_type,
        'interaction_intensity': r.interaction_intensity,
    }


@api_view(['GET'])
def graph_data(request):
    """Возвращает граф: nodes + edges для vis.js."""
    contacts = Contact.objects.all()
    nodes = [
        {
            'id': c.id,
            'label': c.name,
            'title': '\n'.join(filter(None, [c.organization, c.position, c.email])),
            'group': c.organization or 'default',
        }
        for c in contacts
    ]
    relations = Relation.objects.select_related('source', 'target').all()
    edges = [_edge_from_relation(r) for r in relations]
    return Response({'nodes': nodes, 'edges': edges})


@api_view(['GET'])
def network_map_graph(request):
    """Граф для конкретной карты сети: участники и связи между ними."""
    map_id = request.query_params.get('map_id')
    if not map_id:
        default_map = NetworkMap.objects.order_by('id').first()
        if not default_map:
            return Response({'nodes': [], 'edges': []})
        map_id = default_map.id

    memberships = list(
        NetworkMapMembership.objects.filter(map_id=map_id)
        .select_related('contact')
        .order_by('contact__name')
    )
    allowed_ids = {m.contact_id for m in memberships}
    nodes = [_node_from_membership(m) for m in memberships]
    relations = Relation.objects.select_related('source', 'target').all()
    edges = [
        _edge_from_relation(r)
        for r in relations
        if r.source_id in allowed_ids and r.target_id in allowed_ids
    ]
    return Response({'nodes': nodes, 'edges': edges})


@api_view(['GET'])
def relation_types(request):
    """Список допустимых типов связей."""
    return Response([{'value': v, 'label': l} for v, l in RELATION_TYPES])


@api_view(['GET'])
def network_map_choices(request):
    """Подписи для карты сети: сферы, круги, интенсивность связей."""
    return Response({
        'life_spheres': [{'value': v, 'label': l} for v, l in LIFE_SPHERES],
        'network_circles': [{'value': v, 'label': l} for v, l in NETWORK_CIRCLES],
        'interaction_intensities': [{'value': v, 'label': l} for v, l in INTERACTION_INTENSITY],
    })


def _monica_contact_fields(contact_data):
    """Из вложенного data контакта Monica (экспорт account.data) извлекает телефон, email, заметки."""
    phone = ''
    email = ''
    notes_parts = []
    for block in contact_data or []:
        if block.get('type') == 'contact_field':
            for val in block.get('values') or []:
                props = val.get('properties') or {}
                value = str(props.get('data') or '').strip()
                if not value:
                    continue
                if '@' in value and '.' in value:
                    email = email or value
                else:
                    phone = phone or value
        elif block.get('type') == 'note':
            for val in block.get('values') or []:
                body = str((val.get('properties') or {}).get('body') or '').strip()
                if body:
                    notes_parts.append(body)
    return phone, email, '\n'.join(notes_parts)


def _normalize_rows(data):
    """
    Нормализует различные форматы JSON в плоский список словарей.

    Поддерживает:
    - Плоский массив:        [{"name": ...}, ...]
    - Monica CRM (экспорт):  {"account": {"data": [{"type": "contact", "values": [...]}]}}
    - Monica CRM (старый):  {"contacts": [{"first_name": ..., "last_name": ...}, ...]}
    - Обёртка results:      {"results": [...]}
    - Обёртка data:         {"data": [...]}
    """
    if isinstance(data, list):
        return data
    if isinstance(data, dict):
        # Monica CRM полный экспорт: account.data, блоки type=contact, values[].properties + data
        account = data.get('account')
        if isinstance(account, dict):
            account_data = account.get('data')
            if isinstance(account_data, list):
                rows = []
                for block in account_data:
                    if block.get('type') != 'contact':
                        continue
                    for c in block.get('values') or []:
                        props = c.get('properties') or {}
                        first = str(props.get('first_name') or '').strip()
                        last = str(props.get('last_name') or '').strip()
                        middle = str(props.get('middle_name') or '').strip()
                        name = ' '.join(filter(None, [first, middle, last])) or ' '.join(
                            filter(None, [first, last])
                        )
                        if not name:
                            continue
                        phone, email, notes = _monica_contact_fields(c.get('data'))
                        rows.append({
                            'name': name,
                            'email': email,
                            'phone': phone,
                            'organization': '',
                            'position': '',
                            'notes': notes,
                        })
                if rows:
                    return rows
        # Monica CRM: ключ "contacts" с first_name/last_name (старый формат API)
        if 'contacts' in data:
            rows = []
            for c in data['contacts']:
                first = str(c.get('first_name') or '').strip()
                last = str(c.get('last_name') or '').strip()
                name = ' '.join(filter(None, [first, last]))
                # Телефоны Monica хранятся в списке phone_numbers
                phone = ''
                for ph in c.get('phone_numbers') or []:
                    phone = str(ph.get('number') or ph.get('content') or '')
                    if phone:
                        break
                # Email Monica — список emails
                email = ''
                for em in c.get('emails') or []:
                    email = str(em.get('email') or em.get('content') or '')
                    if email:
                        break
                # Организации Monica — список companies
                org = ''
                position = ''
                for comp in c.get('companies') or []:
                    org = str(comp.get('name') or comp.get('company_name') or '')
                    position = str(comp.get('job') or comp.get('position') or comp.get('title') or '')
                    if org:
                        break
                # Также бывает прямое поле company
                if not org:
                    org = str(c.get('company') or c.get('company_name') or '').strip()
                    position = str(c.get('job') or c.get('position') or '').strip()
                rows.append({
                    'name': name,
                    'email': email,
                    'phone': phone,
                    'organization': org,
                    'position': position,
                    'notes': str(c.get('information') or c.get('description') or c.get('notes') or '').strip(),
                })
            return rows
        # Другие обёртки
        for key in ('results', 'data', 'items', 'people', 'persons'):
            if key in data and isinstance(data[key], list):
                return data[key]
    return []


def _unfold_vcard_lines(text):
    lines = text.replace('\r\n', '\n').replace('\r', '\n').split('\n')
    unfolded = []
    for line in lines:
        if line.startswith((' ', '\t')) and unfolded:
            unfolded[-1] += line[1:]
        else:
            unfolded.append(line)
    return unfolded


def _unescape_vcard_value(value):
    return (
        str(value or '')
        .replace('\\n', '\n')
        .replace('\\N', '\n')
        .replace('\\,', ',')
        .replace('\\;', ';')
        .replace('\\\\', '\\')
        .strip()
    )


def _name_from_vcard_n(value):
    parts = _unescape_vcard_value(value).split(';')
    family = (parts[0] if len(parts) > 0 else '').strip()
    given = (parts[1] if len(parts) > 1 else '').strip()
    additional = (parts[2] if len(parts) > 2 else '').strip()
    return ' '.join(filter(None, [given, additional, family])).strip()


def _parse_vcf_rows(text):
    props = None
    rows = []
    for line in _unfold_vcard_lines(text):
        trimmed = line.strip()
        if not trimmed:
            continue
        upper = trimmed.upper()
        if upper == 'BEGIN:VCARD':
            props = {}
            continue
        if upper == 'END:VCARD':
            if props:
                name = (
                    (props.get('FN') or [''])[0]
                    or _name_from_vcard_n((props.get('N') or [''])[0])
                ).strip()
                org_raw = (props.get('ORG') or [''])[0]
                org = org_raw.split(';')[0].strip() if org_raw else ''
                email = (props.get('EMAIL') or [''])[0].replace('mailto:', '').strip()
                phone = (props.get('TEL') or [''])[0].replace('tel:', '').strip()
                rows.append({
                    'name': name,
                    'email': email,
                    'phone': phone,
                    'organization': org,
                    'position': (props.get('TITLE') or [''])[0].strip(),
                    'notes': '\n'.join(props.get('NOTE') or []).strip(),
                })
            props = None
            continue
        if props is None:
            continue
        if ':' not in trimmed:
            continue
        raw_key, value = trimmed.split(':', 1)
        key = raw_key.split(';')[0].upper()
        decoded = _unescape_vcard_value(value.replace('mailto:', '').replace('tel:', ''))
        props.setdefault(key, []).append(decoded)
    return rows


@api_view(['POST'])
def import_contacts(request):
    """
    Импорт контактов из CSV, JSON или vCard (.vcf).

    CSV: name,email,phone,organization,position,notes
    JSON (плоский): [{"name": "...", ...}, ...]
    JSON (Monica CRM): {"contacts": [{"first_name": ..., "last_name": ...}, ...]}
    vCard: экспорт из телефона / Google Contacts (.vcf)
    """
    file = request.FILES.get('file')
    if not file:
        return Response({'error': 'Файл не передан.'}, status=status.HTTP_400_BAD_REQUEST)

    filename = file.name.lower()
    created = 0
    skipped = 0
    errors = []

    try:
        if filename.endswith('.csv'):
            text = file.read().decode('utf-8-sig')
            reader = csv.DictReader(io.StringIO(text))
            rows = list(reader)
        elif filename.endswith('.json'):
            raw = json.loads(file.read().decode('utf-8'))
            rows = _normalize_rows(raw)
            if not rows:
                return Response(
                    {'error': 'Не удалось распознать формат JSON. Ожидается массив контактов или экспорт Monica CRM.'},
                    status=status.HTTP_400_BAD_REQUEST,
                )
        elif filename.endswith('.vcf') or filename.endswith('.vcard'):
            text = file.read().decode('utf-8-sig')
            rows = _parse_vcf_rows(text)
            if not rows:
                return Response(
                    {'error': 'В файле vCard не найдено контактов.'},
                    status=status.HTTP_400_BAD_REQUEST,
                )
        else:
            return Response(
                {'error': 'Поддерживаются только CSV, JSON и vCard (.vcf) файлы.'},
                status=status.HTTP_400_BAD_REQUEST,
            )
    except Exception as e:
        return Response({'error': f'Ошибка разбора файла: {e}'}, status=status.HTTP_400_BAD_REQUEST)

    total_rows = len(rows)
    for i, row in enumerate(rows):
        name = str(
            row.get('name') or row.get('Name') or row.get('ФИО') or
            ' '.join(filter(None, [
                str(row.get('first_name') or '').strip(),
                str(row.get('last_name') or '').strip(),
            ]))
        ).strip()
        if not name:
            errors.append(f'Строка {i + 1}: отсутствует поле "name"')
            skipped += 1
            continue

        Contact.objects.get_or_create(
            name=name,
            defaults={
                'email': str(row.get('email') or '').strip(),
                'phone': str(row.get('phone') or '').strip(),
                'organization': str(row.get('organization') or '').strip(),
                'position': str(row.get('position') or '').strip(),
                'notes': str(row.get('notes') or '').strip(),
            },
        )
        created += 1

    return Response({
        'total': total_rows,
        'created': created,
        'skipped': skipped,
        'errors': errors,
    })