from flask import Blueprint, request, jsonify
from src.models.user import db, User
from src.utils.user_ref import resolve_user_ref
from src.models.post import Post, Comment
from datetime import datetime

post_bp = Blueprint('post', __name__)

@post_bp.route('/posts', methods=['GET'])
def get_posts():
    """게시글 목록 조회"""
    try:
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 10, type=int)
        category = request.args.get('category', '')
        
        query = Post.query
        if category:
            query = query.filter(Post.category == category)
        
        posts = query.order_by(Post.created_at.desc()).paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        return jsonify({
            'posts': [post.to_dict() for post in posts.items],
            'total': posts.total,
            'pages': posts.pages,
            'current_page': page
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@post_bp.route('/posts', methods=['POST'])
def create_post():
    """게시글 작성"""
    try:
        data = request.get_json()
        
        # 필수 필드 검증
        required_fields = ['title', 'content', 'category', 'author_id']
        for field in required_fields:
            if field not in data:
                return jsonify({'error': f'{field} is required'}), 400
        
        # 사용자 존재 확인
        user = resolve_user_ref(data['author_id'])
        if not user:
            return jsonify({'error': 'User not found'}), 404
        
        post = Post(
            title=data['title'],
            content=data['content'],
            category=data['category'],
            author_id=user.user_id,
        )
        
        db.session.add(post)
        db.session.commit()
        
        return jsonify(post.to_dict()), 201
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': str(e)}), 500

@post_bp.route('/posts/<int:post_id>', methods=['GET'])
def get_post(post_id):
    """게시글 상세 조회"""
    try:
        post = Post.query.get_or_404(post_id)
        
        # 조회수 증가
        post.views += 1
        db.session.commit()
        
        # 댓글 포함하여 반환
        post_data = post.to_dict()
        post_data['comments'] = [comment.to_dict() for comment in post.comments if comment.parent_id is None]
        
        return jsonify(post_data)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@post_bp.route('/posts/<int:post_id>', methods=['PUT'])
def update_post(post_id):
    """게시글 수정"""
    try:
        post = Post.query.get_or_404(post_id)
        data = request.get_json()
        
        # 작성자 확인 (실제로는 인증 미들웨어에서 처리해야 함)
        if 'author_id' in data:
            other = resolve_user_ref(data['author_id'])
            if not other or other.user_id != post.author_id:
                return jsonify({'error': 'Unauthorized'}), 403
        
        # 수정 가능한 필드만 업데이트
        updatable_fields = ['title', 'content', 'category']
        for field in updatable_fields:
            if field in data:
                setattr(post, field, data[field])
        
        post.updated_at = datetime.now()
        db.session.commit()
        
        return jsonify(post.to_dict())
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': str(e)}), 500

@post_bp.route('/posts/<int:post_id>', methods=['DELETE'])
def delete_post(post_id):
    """게시글 삭제"""
    try:
        post = Post.query.get_or_404(post_id)
        
        # 작성자 확인 (실제로는 인증 미들웨어에서 처리해야 함)
        # if post.author_id != current_user_id:
        #     return jsonify({'error': 'Unauthorized'}), 403
        
        db.session.delete(post)
        db.session.commit()
        
        return jsonify({'message': 'Post deleted successfully'})
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': str(e)}), 500

@post_bp.route('/posts/<int:post_id>/comments', methods=['POST'])
def create_comment(post_id):
    """댓글 작성"""
    try:
        post = Post.query.get_or_404(post_id)
        data = request.get_json()
        
        # 필수 필드 검증
        required_fields = ['content', 'author_id']
        for field in required_fields:
            if field not in data:
                return jsonify({'error': f'{field} is required'}), 400
        
        # 사용자 존재 확인
        user = resolve_user_ref(data['author_id'])
        if not user:
            return jsonify({'error': 'User not found'}), 404
        
        comment = Comment(
            content=data['content'],
            post_id=post_id,
            author_id=user.user_id,
            parent_id=data.get('parent_id')  # 대댓글인 경우
        )
        
        db.session.add(comment)
        db.session.commit()
        
        return jsonify(comment.to_dict()), 201
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': str(e)}), 500

@post_bp.route('/posts/<int:post_id>/like', methods=['POST'])
def like_post(post_id):
    """게시글 좋아요"""
    try:
        post = Post.query.get_or_404(post_id)
        data = request.get_json()
        
        if 'user_id' not in data:
            return jsonify({'error': 'user_id is required'}), 400
        
        # 실제로는 중복 좋아요 방지 로직 필요
        post.likes += 1
        db.session.commit()
        
        return jsonify({'likes': post.likes})
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': str(e)}), 500

@post_bp.route('/categories', methods=['GET'])
def get_categories():
    """게시판 카테고리 목록"""
    categories = [
        {'id': 'notice', 'name': '공지사항'},
        {'id': 'update', 'name': '업데이트'},
        {'id': 'guide', 'name': '가이드'},
        {'id': 'qna', 'name': '문의/답변'},
        {'id': 'tip', 'name': '이용 꿀팁'},
        {'id': 'faq', 'name': '자주 묻는 질문'},
        {'id': 'free', 'name': '자유게시판'},
        {'id': 'request', 'name': '기능 요청'}
    ]
    return jsonify(categories)