"""
Portfolio API Routes
CRUD operations for worker portfolio items
"""
from flask import jsonify, request
from flask_login import login_required, current_user
import logging

from . import portfolio_bp
from ...models.portfolio import PortfolioItem
from ...extensions import db

logger = logging.getLogger(__name__)


@portfolio_bp.route('/<int:user_id>', methods=['GET'])
def get_portfolio(user_id):
    """Get a worker's portfolio items"""
    try:
        items = PortfolioItem.query.filter_by(worker_id=user_id)\
            .order_by(PortfolioItem.display_order.asc(), PortfolioItem.created_at.desc())\
            .all()

        return jsonify({
            "items": [item.to_dict() for item in items],
            "total": len(items),
            "worker_id": user_id
        }), 200

    except Exception as e:
        logger.error(f"Error getting portfolio: {str(e)}")
        return jsonify({"error": "Failed to get portfolio"}), 500


@portfolio_bp.route('/upload', methods=['POST'])
@login_required
def upload_portfolio_item():
    """Upload a new portfolio item"""
    try:
        if current_user.role != 'worker':
            return jsonify({"error": "Only workers can upload portfolio items"}), 403

        # Handle both JSON and form data
        if request.is_json:
            data = request.get_json()
            title = data.get('title')
            description = data.get('description', '')
            image_url = data.get('image_url')
            trade_category = data.get('trade_category')
            contract_id = data.get('contract_id')
        else:
            title = request.form.get('title')
            description = request.form.get('description', '')
            trade_category = request.form.get('trade_category')
            contract_id = request.form.get('contract_id')
            image_url = None

            # Handle file upload
            if 'image' in request.files:
                from ...services.file_storage_service import file_storage_service
                file = request.files['image']
                if file.filename:
                    result = file_storage_service.upload_file(file, folder='portfolio')
                    image_url = result.get('url') if result else None

        if not title:
            return jsonify({"error": "Title is required"}), 400
        if not image_url:
            return jsonify({"error": "Image is required"}), 400

        # Get max display order
        max_order = db.session.query(db.func.max(PortfolioItem.display_order))\
            .filter_by(worker_id=current_user.id).scalar() or 0

        item = PortfolioItem(
            worker_id=current_user.id,
            title=title[:200],
            description=description[:1000] if description else None,
            image_url=image_url,
            trade_category=trade_category[:100] if trade_category else None,
            contract_id=int(contract_id) if contract_id else None,
            display_order=max_order + 1
        )

        db.session.add(item)
        db.session.commit()

        return jsonify({
            "message": "Portfolio item added successfully",
            "item": item.to_dict()
        }), 201

    except Exception as e:
        db.session.rollback()
        logger.error(f"Error uploading portfolio item: {str(e)}")
        return jsonify({"error": f"Failed to upload: {str(e)}"}), 500


@portfolio_bp.route('/<int:item_id>', methods=['DELETE'])
@login_required
def delete_portfolio_item(item_id):
    """Delete a portfolio item"""
    try:
        item = PortfolioItem.query.get(item_id)
        if not item:
            return jsonify({"error": "Item not found"}), 404

        if item.worker_id != current_user.id:
            return jsonify({"error": "Not authorized to delete this item"}), 403

        db.session.delete(item)
        db.session.commit()

        return jsonify({"message": "Portfolio item deleted"}), 200

    except Exception as e:
        db.session.rollback()
        logger.error(f"Error deleting portfolio item: {str(e)}")
        return jsonify({"error": "Failed to delete item"}), 500


@portfolio_bp.route('/<int:item_id>/reorder', methods=['PUT'])
@login_required
def reorder_portfolio_item(item_id):
    """Change display order of a portfolio item"""
    try:
        item = PortfolioItem.query.get(item_id)
        if not item:
            return jsonify({"error": "Item not found"}), 404

        if item.worker_id != current_user.id:
            return jsonify({"error": "Not authorized"}), 403

        data = request.get_json()
        new_order = data.get('display_order', 0)
        item.display_order = int(new_order)

        db.session.commit()

        return jsonify({
            "message": "Order updated",
            "item": item.to_dict()
        }), 200

    except Exception as e:
        db.session.rollback()
        return jsonify({"error": "Failed to reorder"}), 500