Survey Management

# Vessel Data Processing Pipeline
def process_fleet_compliance():
    """
    Main processing pipeline for fleet-wide compliance monitoring
    """
    # Retrieve active vessel fleet
    active_vessels = get_active_vessel_fleet()
    
    # Process each classification society
    for society in ['DNV', 'ABS', 'NK', 'BV', 'CCS', 'LR', 'KR', 'IRS', 'RINA']:
        society_vessels = filter_vessels_by_class(active_vessels, society)
        
        # Extract compliance data for each vessel
        for vessel in society_vessels:
            survey_data = extract_survey_status(vessel, society)
            certificate_data = extract_certificate_status(vessel, society)
            
            # Process and analyze compliance status
            compliance_status = analyze_compliance(survey_data, certificate_data)
            
            # Update vessel compliance database
            update_vessel_compliance(vessel['imo'], compliance_status)
    
    return generate_fleet_compliance_report()

# Fetch active vessel fleet
active_vessel_fleet = pd.DataFrame(
    list(vessel_database.find(
        {"status": "ACTIVE"}, 
        {"_id": 0, "imo": 1, "vesselName": 1, "class": 1, "flag": 1}
    ))
)

def select_next_survey(periodic_surveys_df):
    """
    Selects the next survey with maritime industry priority logic:
    Special Survey > Intermediate Survey > Annual Survey
    """
    if periodic_surveys_df.empty:
        return None

    # Group surveys by due date
    grouped = periodic_surveys_df.groupby("periodical_date")
    sorted_dates = sorted(grouped.groups.keys())

    for date in sorted_dates:
        same_date_surveys = grouped.get_group(date)
        survey_names = same_date_surveys["surveyName"].tolist()

        # Maritime industry priority hierarchy
        if "Special Survey" in survey_names:
            return same_date_surveys[same_date_surveys["surveyName"] == "Special Survey"].iloc[0]
        elif "Intermediate Survey" in survey_names:
            return same_date_surveys[same_date_surveys["surveyName"] == "Intermediate Survey"].iloc[0]
        elif "Annual Survey" in survey_names:
            return same_date_surveys[same_date_surveys["surveyName"] == "Annual Survey"].iloc[0]
        else:
            return same_date_surveys.iloc[0]

    return periodic_surveys_df.sort_values(by='periodical_date').iloc[0]

def parse_maritime_dates(date_field):
    """
    Handles multiple date formats from different classification societies
    """
    try:
        if date_field and date_field != "--":
            if isinstance(date_field, str):
                if "-" in date_field and len(date_field.split("-")) == 3:
                    return pd.to_datetime(date_field)  # ISO format
                elif "T" in date_field and "+" in date_field:
                    return pd.to_datetime(date_field, format="%Y-%m-%dT%H:%M:%S.%f%z")  # MongoDB format
                else:
                    return pd.to_datetime(date_field, format='%d %b %Y')  # Maritime standard
            elif isinstance(date_field, dict) and '$date' in date_field:
                return pd.to_datetime(date_field['$date'])  # MongoDB date object
            else:
                return pd.to_datetime(date_field)
        return None
    except Exception:
        return None

def calculate_certificate_status(vessel_class, cms_details):
    """
    Calculates certificate status with class-specific logic for:
    - Safety Management Certificate (SMC)
    - Document of Compliance (DOC)  
    - International Safety Management (ISM)
    - Maritime Labour Certificate (MLC)
    """
    if not isinstance(cms_details, list) or len(cms_details) == 0:
        return {"status": "In Order", "color": "green", "order": 4}

    for detail in cms_details:
        due_date = detail.get('dueDate')
        postponed_date = detail.get('extendedDate')
        done_date = detail.get('doneDate')
        last_date = detail.get('lastDate')

        # Check for recently completed certificates (within 365 days)
        if last_date and 1 <= (datetime.now() - last_date).days <= 365:
            return {"status": "Credited", "color": "green", "order": 3}
        if done_date and 1 <= (datetime.now() - done_date).days <= 365:
            return {"status": "Credited", "color": "green", "order": 3}

        # Class-specific date handling
        dates = {
            "NK": [due_date, postponed_date],
            "LR": [due_date, postponed_date], 
            "CCS": [due_date, postponed_date],
            "IRS": [due_date, postponed_date],
            "BV": [due_date, postponed_date],
            "ABS": [due_date, postponed_date],
            "RINA": [due_date],  # RINA only uses due_date
            "KR": [due_date, postponed_date],
            "DNV": [due_date, postponed_date]
        }.get(vessel_class, [due_date, postponed_date])

        valid_dates = [d for d in dates if pd.notnull(d)]
        if not valid_dates:
            continue

        max_date = max(valid_dates)
        days_diff = (max_date - datetime.now()).days

        if days_diff <= 0:
            return {"status": "Overdue", "color": "red", "order": 1}
        elif days_diff <= 90:
            return {"status": f"Due in {days_diff} days", "color": "orange", "order": 2}

    return {"status": "In Order", "color": "green", "order": 4}

def upload_to_s3_certificate(file_content, file_name, imo_number):
    """
    Uploads certificates to S3 with organized folder structure:
    CLASS/{ClassificationSociety}/Certificates/{IMO}/
    """
    s3_client = boto3.client("s3", 
        aws_access_key_id=aws_access_key,
        aws_secret_access_key=aws_secret_key,
        region_name=aws_region)
    
    folder_path = f"CLASS/NK/Certificates/{imo_number}/"
    
    # Determine content type for maritime documents
    content_type = "application/pdf"
    if file_name.lower().endswith((".tif", ".tiff")):
        content_type = "image/tiff"
    elif file_name.lower().endswith(".pdf"):
        content_type = "application/pdf"
    
    s3_client.put_object(
        Bucket=bucket_name,
        Key=folder_path + file_name,
        Body=file_content,
        ContentType=content_type
    )
    
def upload_survey_status(file_content, file_name, imo):
    """
    Uploads survey status reports with date-organized structure:
    CLASS/{Society}/Survey_Status/{IMO}/{Year}/{Month}/
    """
    folder_path = f"CLASS/ABS/Survey_Status/{imo}/{datetime.now().year}/{datetime.now().month}.{datetime.now().strftime('%b')}/"
    # Upload logic...

def generate_compliance_notifications(vessel_compliance_data):
    """
    Generates intelligent notifications based on compliance status and urgency
    """
    notifications = []
    
    for vessel in vessel_compliance_data:
        compliance_status = vessel['compliance_status']
        vessel_info = vessel['vessel_info']
        
        # Determine notification priority and recipients
        if compliance_status['has_overdue_items']:
            priority = 'HIGH'
            notification_type = 'URGENT_COMPLIANCE_ALERT'
        elif compliance_status['items_due_within_30_days']:
            priority = 'MEDIUM'
            notification_type = 'UPCOMING_DEADLINE_ALERT'
        else:
            priority = 'LOW'
            notification_type = 'STATUS_UPDATE'
        
        # Create notification package
        notification = {
            'vessel_imo': vessel_info['imo'],
            'vessel_name': vessel_info['name'],
            'priority': priority,
            'type': notification_type,
            'compliance_summary': compliance_status['summary'],
            'action_items': compliance_status['action_required'],
            'deadline_info': compliance_status['next_deadline']
        }
        
        notifications.append(notification)
    
    # Route notifications through appropriate channels
    route_notifications(notifications)
    
    return notifications