//
// This file describes the API that the generator will produce
//
// Authors:
//   Miguel de Icaza
//   Marek Safar (marek.safar@gmail.com)
//
// Copyright 2010, Novell, Inc.
// Copyright 2012-2015, Xamarin Inc.
//

#if !WATCH
using XamCore.AddressBook;
#endif
using XamCore.ObjCRuntime;
using XamCore.Foundation;
using XamCore.CoreGraphics;
using XamCore.CoreLocation;
#if XAMCORE_2_0
using XamCore.MapKit;
#endif
using System;
#if MONOMAC
using XamCore.AppKit;
#else
using XamCore.UIKit;
#endif

namespace XamCore.EventKit {

	[Since (5,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (NSObject))]
#if XAMCORE_2_0 || MONOMAC
	[Abstract]
#endif
	interface EKObject {
		[Export ("hasChanges")]
		bool HasChanges { get; }

		[Export ("isNew")]
		bool IsNew { get; }

		[Export ("reset")]
		void Reset ();

		[Export ("rollback")]
		void Rollback ();

		[Export ("refresh")]
		bool Refresh ();
	}

	[Since (5,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKObject))]
	interface EKCalendarItem {
#if !MONOMAC
		// Never made avaialble on MonoMac
		[Export ("UUID")]
		[Availability (Introduced = Platform.iOS_5_0, Deprecated = Platform.iOS_6_0, Message = "Use CalendarItemIdentifier instead")]
		string UUID { get;  }
#endif

		[NullAllowed] // by default this property is null
		[Export ("calendar", ArgumentSemantic.Retain)]
		EKCalendar Calendar { get; set;  }

		[NullAllowed] // by default this property is null
		[Export ("title", ArgumentSemantic.Copy)]
		string Title { get; set;  }

		[NullAllowed] // it's null by default on iOS 6.1
		[Export ("location", ArgumentSemantic.Copy)]
		string Location { get; set;  }

		[Export ("notes", ArgumentSemantic.Copy)]
		[NullAllowed]
		string Notes { get; set;  }

		[NullAllowed] // by default this property is null
		[Export ("URL", ArgumentSemantic.Copy)]
		NSUrl Url { get; set;  }

		[Export ("lastModifiedDate")]
		NSDate LastModifiedDate { get;  }

		[Export ("creationDate")]
		NSDate CreationDate { get;  }

		[NullAllowed] // by default this property is null
		[Export ("timeZone", ArgumentSemantic.Copy)]
		NSTimeZone TimeZone { get; set;  }

		[Export ("hasAlarms")]
		bool HasAlarms { get;  }

		[Export ("hasRecurrenceRules")]
		bool HasRecurrenceRules { get;  }

		[Export ("hasAttendees")]
		bool HasAttendees { get;  }

		[Export ("hasNotes")]
		bool HasNotes { get;  }

		[Export ("attendees")]
		EKParticipant [] Attendees { get;  }

		[NullAllowed] // by default this property is null
		[Export ("alarms", ArgumentSemantic.Copy)]
		EKAlarm [] Alarms { get; set;  }

		[Export ("recurrenceRules", ArgumentSemantic.Copy)]
		EKRecurrenceRule [] RecurrenceRules { get; set;  }

		[Export ("addAlarm:")]
		void AddAlarm (EKAlarm alarm);

		[Export ("removeAlarm:")]
		void RemoveAlarm (EKAlarm alarm);

		[Export ("addRecurrenceRule:")]
		void AddRecurrenceRule (EKRecurrenceRule rule);

		[Export ("removeRecurrenceRule:")]
		void RemoveRecurrenceRule (EKRecurrenceRule rule);

		[Since(6,0)]
		[Export ("calendarItemIdentifier")]
		string CalendarItemIdentifier { get;  }

		[Since(6,0)]
		[Export ("calendarItemExternalIdentifier")]
		string CalendarItemExternalIdentifier { get;  }
	}
	
	[Since (5,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKObject))]
	interface EKSource {
		[Export ("sourceType")]
		EKSourceType SourceType { get;  }

		[Export ("title")]
		string Title { get;  }

#if !MONOMAC
		[Export ("calendars")]
		[Availability (Introduced = Platform.iOS_4_0, Deprecated = Platform.iOS_6_0, Message = "Use GetCalendars (EKEntityType) instead")]
		NSSet Calendars { get;  }
#endif

		[Export ("sourceIdentifier")]
		string SourceIdentifier { get; }

		[Since (6, 0)]
		[Export ("calendarsForEntityType:")]
		NSSet GetCalendars (EKEntityType entityType);
	}

	[Since (6,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKObject))]
	interface EKStructuredLocation : NSCopying {
		[NullAllowed] // by default this property is null
		[Export ("title", ArgumentSemantic.Strong)]
		string Title { get; set;  }

		[NullAllowed] // by default this property is null
		[Export ("geoLocation", ArgumentSemantic.Strong)]
		CLLocation GeoLocation { get; set;  }

		[Export ("radius")]
		double Radius { get; set;  }

		[Export ("locationWithTitle:"), Static]
		EKStructuredLocation FromTitle (string title);

#if XAMCORE_2_0
		[iOS (9,0), Mac(10,11)]
		[Static]
		[Export ("locationWithMapItem:")]
		EKStructuredLocation FromMapItem (MKMapItem mapItem);
#endif
	}

	[Since (4,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKObject))]
	interface EKAlarm : NSCopying {
		[Export ("relativeOffset")]
		double RelativeOffset { get; set;  }

		[Export ("absoluteDate", ArgumentSemantic.Copy)]
		[NullAllowed]
		NSDate AbsoluteDate { get; set;  }

		[Static]
		[Export ("alarmWithAbsoluteDate:")]
		EKAlarm FromDate (NSDate date);

		[Static]
		[Export ("alarmWithRelativeOffset:")]
		EKAlarm FromTimeInterval (double offsetSeconds);

		[Since (6,0)]
		[Export ("structuredLocation", ArgumentSemantic.Copy)]
		[NullAllowed]
		EKStructuredLocation StructuredLocation { get; set;  }

		[Since (6,0)]
		[Export ("proximity")]
		EKAlarmProximity Proximity { get; set;  }

#if MONOMAC
		[Export ("type")]
		EKAlarmType Type { get; }

		[Export ("emailAddress")]
		string EmailAddress { get; set; }

		[Export ("soundName")]
		string SoundName { get; set; }

		[Export ("url", ArgumentSemantic.Copy)]
		NSUrl Url { get; set; }
#endif
	}

	[Since (4,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKObject))]
	[DisableDefaultCtor]
	interface EKCalendar {
		[Export ("title", ArgumentSemantic.Copy)]
		string Title { get; set; }

		[Export ("type")]
		EKCalendarType Type { get;  }

		[Export ("allowsContentModifications")]
		bool AllowsContentModifications { get;  }

#if MONOMAC
		[Export ("color", ArgumentSemantic.Copy)]
		NSColor Color { get; set; }
#else
		[Export ("CGColor")]
		CGColor CGColor { get; set; }
#endif

		[Export ("supportedEventAvailabilities")]
		EKCalendarEventAvailability SupportedEventAvailabilities { get; }

		[Since (5,0)]
		[Export ("calendarIdentifier")]
		string CalendarIdentifier { get;  }

		[Since (5,0)]
		[Export ("subscribed")]
		bool Subscribed { [Bind ("isSubscribed")] get;  }

		[Since (5,0)]
		[Export ("immutable")]
		bool Immutable { [Bind ("isImmutable")] get;  }

#if !MONOMAC
		[Since (5,0)]
		[Availability (Introduced = Platform.iOS_4_0, Deprecated = Platform.iOS_6_0, Message = "Use Create (EKEntityType, EKEventStore) instead")]
		[Static, Export ("calendarWithEventStore:")]
		EKCalendar FromEventStore (EKEventStore eventStore);
#endif

		[Since (5,0)]
		[Export ("source", ArgumentSemantic.Retain)]
		EKSource Source { get; set; }

		[Since (6,0)]
		[Export ("allowedEntityTypes")]
		EKEntityMask AllowedEntityTypes { get;  }

		[Since (6,0)]
		[Static]
		[Export ("calendarForEntityType:eventStore:")]
		EKCalendar Create (EKEntityType entityType, EKEventStore eventStore);
	}

	[Since (4,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKCalendarItem))]
	// Objective-C exception thrown.  Name: NSInvalidArgumentException Reason: You must use [EKEvent eventWithStore:] to create an event
	[DisableDefaultCtor]
	interface EKEvent {
		[Static, Export ("eventWithEventStore:")]
		EKEvent FromStore (EKEventStore eventStore);

		[Export ("allDay")]
		bool AllDay { [Bind ("isAllDay")] get; set;  }

		[Export ("startDate", ArgumentSemantic.Copy)]
		NSDate StartDate { get; set;  }

		[Export ("endDate", ArgumentSemantic.Copy)]
		NSDate EndDate { get; set;  }

		[Export ("organizer")]
		EKParticipant Organizer { get;  }

		[Export ("isDetached")]
		bool IsDetached { get;  }

		[Export ("eventIdentifier")]
		string EventIdentifier { get; }

		[Export ("compareStartDateWithEvent:")]
		NSComparisonResult CompareStartDateWithEvent (EKEvent other);

		[Export ("refresh")]
		bool Refresh ();

		[Export  ("availability")]
		EKEventAvailability Availability { get; set; }

		[Export ("status")]
		EKEventStatus Status { get; }

		[iOS (9,0), Mac(10,11)]
		[NullAllowed, Export ("structuredLocation", ArgumentSemantic.Copy)]
		EKStructuredLocation StructuredLocation { get; set; }
		
		[iOS (9,0)][Mac (10,8)]
		[Export ("occurrenceDate")]
		NSDate OccurrenceDate { get; }

#if MONOMAC
		[Availability (Introduced = Platform.Mac_10_8, Deprecated = Platform.Mac_10_11, Message = "Replaced by BirthdayContactIdentifier")]
		[Export ("birthdayPersonUniqueID")]
		string BirthdayPersonUniqueID { get; }
#else
		[Availability (Introduced = Platform.iOS_5_0, Deprecated = Platform.iOS_9_0, Message = "Replaced by BirthdayContactIdentifier")]
		[Export ("birthdayPersonID")]
		nint BirthdayPersonID { get;  }
#endif
		[iOS (9,0)][Mac (10,11)]
		[NullAllowed, Export ("birthdayContactIdentifier")]
		string BirthdayContactIdentifier { get; }
	}

	[Since (4,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKObject))]
#if XAMCORE_3_0
	[DisableDefaultCtor]
#endif
	interface EKParticipant : NSCopying {
		[Export ("URL")]
		NSUrl Url { get;  }

		[Export ("name")]
		string Name { get;  }

		[Export ("participantStatus")]
		EKParticipantStatus ParticipantStatus { get;  }

		[Export ("participantRole")]
		EKParticipantRole ParticipantRole { get;  }

		[Export ("participantType")]
		EKParticipantType ParticipantType { get;  }

#if MONOMAC
// missing some Mac support for the address book
//		[Export ("ABPersonInAddressBook:")]
//		ABPerson GetPerson (ABAddressBook addressBook);
#else
#if !WATCH
		[Availability (Introduced = Platform.iOS_4_0, Deprecated = Platform.iOS_9_0, Message = "Replaced by ContactPredicate")]
		[Export ("ABRecordWithAddressBook:")]
		ABRecord GetRecord (ABAddressBook addressBook);
#endif // !WATCH

#endif
		[Since (6,0)]
		[Mac (10,9)]
		[Export ("isCurrentUser")]
		bool IsCurrentUser { get; }

		[iOS (9,0)][Mac (10,11)]
		[Export ("contactPredicate")]
		NSPredicate ContactPredicate { get; }
	}

	[Since (4,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (NSObject))]
	interface EKRecurrenceEnd : NSCopying {
		[Export ("endDate")]
		NSDate EndDate { get;  }

		[Export ("occurrenceCount")]
		nint OccurrenceCount { get;  }

		[Static]
		[Export ("recurrenceEndWithEndDate:")]
		EKRecurrenceEnd FromEndDate (NSDate endDate);

		[Static]
		[Export ("recurrenceEndWithOccurrenceCount:")]
		EKRecurrenceEnd FromOccurrenceCount (nint occurrenceCount);
	}

	[Since (4,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (NSObject))]
	interface EKRecurrenceDayOfWeek : NSCopying {
		[Export ("dayOfTheWeek")]
#if XAMCORE_4_0
		EKWeekday DayOfTheWeek { get;  }
#else
		nint DayOfTheWeek { get;  }
#endif

		[Export ("weekNumber")]
		nint WeekNumber { get;  }

		[Static]
		[Export ("dayOfWeek:")]
#if XAMCORE_4_0
		EKRecurrenceDayOfWeek FromDay (EKWeekday dayOfTheWeek);
#elif XAMCORE_2_0
		[Internal]
		EKRecurrenceDayOfWeek _FromDay (nint dayOfTheWeek);
#else
		EKRecurrenceDayOfWeek FromDay (EKDay dayOfTheWeek);
#endif

		[Static]
		[Export ("dayOfWeek:weekNumber:")]
#if XAMCORE_4_0
		EKRecurrenceDayOfWeek FromDay (EKWeekday dayOfTheWeek, nint weekNumber);
#elif XAMCORE_2_0
		[Internal]
		EKRecurrenceDayOfWeek _FromDay (nint dayOfTheWeek, nint weekNumber);
#else
		EKRecurrenceDayOfWeek FromDay (EKDay dayOfTheWeek, nint weekNumber);
#endif

		[Since (5,0)]
		[Export ("initWithDayOfTheWeek:weekNumber:")]
#if XAMCORE_4_0
		IntPtr Constructor (EKWeekday dayOfTheWeek, nint weekNumber);
#else
		IntPtr Constructor (nint dayOfTheWeek, nint weekNumber);
#endif
	}

	[Since (4,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKObject))]
	interface EKRecurrenceRule : NSCopying {
		[Export ("calendarIdentifier")]
		string CalendarIdentifier { get;  }

		[NullAllowed] // by default this property is null
		[Export ("recurrenceEnd", ArgumentSemantic.Copy)]
		EKRecurrenceEnd RecurrenceEnd { get; set;  }

		[Export ("frequency")]
		EKRecurrenceFrequency Frequency { get;  }

		[Export ("interval")]
		nint Interval { get;  }

		[Export ("firstDayOfTheWeek")]
#if XAMCORE_4_0
		EKWeekday FirstDayOfTheWeek { get; }
#elif XAMCORE_2_0
		[Internal]
		nint _FirstDayOfTheWeek { get; }
#else
		EKDay FirstDayOfTheWeek { get;  }
#endif

		[Export ("daysOfTheWeek")]
		EKRecurrenceDayOfWeek [] DaysOfTheWeek { get;  }

		[Export ("daysOfTheMonth")]
		NSNumber [] DaysOfTheMonth { get;  }

		[Export ("daysOfTheYear")]
		NSNumber [] DaysOfTheYear { get;  }

		[Export ("weeksOfTheYear")]
		NSNumber [] WeeksOfTheYear { get;  }

		[Export ("monthsOfTheYear")]
		NSNumber [] MonthsOfTheYear { get;  }

		[Export ("setPositions")]
#if XAMCORE_4_0
		NSNumber [] SetPositions { get; }
#else
		NSObject [] SetPositions { get;  }
#endif

		[Export ("initRecurrenceWithFrequency:interval:end:")]
		IntPtr Constructor (EKRecurrenceFrequency type, nint interval, [NullAllowed] EKRecurrenceEnd end);

		[Export ("initRecurrenceWithFrequency:interval:daysOfTheWeek:daysOfTheMonth:monthsOfTheYear:weeksOfTheYear:daysOfTheYear:setPositions:end:")]
		IntPtr Constructor (EKRecurrenceFrequency type, nint interval, [NullAllowed] EKRecurrenceDayOfWeek [] days, [NullAllowed] NSNumber [] monthDays, [NullAllowed] NSNumber [] months,
				    [NullAllowed] NSNumber [] weeksOfTheYear, [NullAllowed] NSNumber [] daysOfTheYear, [NullAllowed] NSNumber [] setPositions, [NullAllowed] EKRecurrenceEnd end);

	}

	[Since (4,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (NSObject))]
	interface EKEventStore {
		[Export ("eventStoreIdentifier")]
		string EventStoreIdentifier { get;  }

#if !MONOMAC
		[Export ("calendars")]
		[Availability (Introduced = Platform.iOS_4_0, Deprecated = Platform.iOS_6_0, Message = "Use GetCalendars instead")]
		EKCalendar [] Calendars { get;  }
#endif

		[Export ("defaultCalendarForNewEvents")]
		EKCalendar DefaultCalendarForNewEvents { get;  }

#if !MONOMAC
		[NoWatch]
		[Export ("saveEvent:span:error:")]
		bool SaveEvent (EKEvent theEvent, EKSpan span, out NSError error);

		[NoWatch]
		[Export ("removeEvent:span:error:")]
		bool RemoveEvents (EKEvent theEvent, EKSpan span, out NSError error);
#endif

		[Export ("eventWithIdentifier:")]
		EKEvent EventFromIdentifier (string identifier);

		[Export ("eventsMatchingPredicate:")]
		EKEvent [] EventsMatching (NSPredicate predicate);

		[Export ("enumerateEventsMatchingPredicate:usingBlock:")]
		void EnumerateEvents (NSPredicate predicate, EKEventSearchCallback block);

		[Export ("predicateForEventsWithStartDate:endDate:calendars:")]
		NSPredicate PredicateForEvents (NSDate startDate, NSDate endDate, [NullAllowed] EKCalendar [] calendars);

		[Field ("EKEventStoreChangedNotification")]
		[Notification]
		NSString ChangedNotification { get; }

		[Since (5,0)]
		[Export ("sources")]
		EKSource [] Sources { get; }

		[Since (5,0)]
		[Export ("sourceWithIdentifier:")]
		EKSource GetSource (string identifier);

		[Since (5,0)]
		[Export ("calendarWithIdentifier:")]
		EKCalendar GetCalendar (string identifier);

		[NoWatch]
		[Since (5,0)]
		[Export ("saveCalendar:commit:error:")]
		bool SaveCalendar (EKCalendar calendar, bool commit, out NSError error);

		[NoWatch]
		[Since (5,0)]
		[Export ("removeCalendar:commit:error:")]
		bool RemoveCalendar (EKCalendar calendar, bool commit, out NSError error);

		[NoWatch]
		[Since (5,0)]
		[Export ("saveEvent:span:commit:error:")]
		bool SaveEvent (EKEvent ekEvent, EKSpan span, bool commit, out NSError error);

		[NoWatch]
		[Since (5,0)]
		[Export ("removeEvent:span:commit:error:")]
		bool RemoveEvent (EKEvent ekEvent, EKSpan span, bool commit, out NSError error);

		[NoWatch]
		[Since (5,0)]
		[Export ("commit:")]
		bool Commit (out NSError error);

		[Since (5,0)]
		[Export ("reset")]
		void Reset ();

		[NoWatch]
		[Since (5,0)]
		[Export ("refreshSourcesIfNecessary")]
		void RefreshSourcesIfNecessary ();

		[Since (6,0)]
		[Export ("calendarItemWithIdentifier:")]
		EKCalendarItem GetCalendarItem (string identifier);

		[Since (6,0)]
		[Export ("calendarItemsWithExternalIdentifier:")]
		EKCalendarItem[] GetCalendarItems(string externalIdentifier);

		[Since (6,0)]
		[Export ("calendarsForEntityType:")]
		EKCalendar[] GetCalendars (EKEntityType entityType);

		[Since (6,0)]
		[Export ("defaultCalendarForNewReminders")]
		EKCalendar DefaultCalendarForNewReminders { get; }

		[Since (6,0)]
		[Export ("fetchRemindersMatchingPredicate:completion:")]
		[Async]
		IntPtr FetchReminders (NSPredicate predicate, Action<EKReminder[]> completion);

		[Since (6,0)]
		[Export ("cancelFetchRequest:")]
		void CancelFetchRequest (IntPtr fetchIdentifier);

		[Since (6,0)]
		[Export ("predicateForIncompleteRemindersWithDueDateStarting:ending:calendars:")]
		NSPredicate PredicateForIncompleteReminders ([NullAllowed] NSDate startDate, [NullAllowed] NSDate endDate, [NullAllowed] EKCalendar[] calendars);

		[Since (6,0)]
		[Export ("predicateForCompletedRemindersWithCompletionDateStarting:ending:calendars:")]
		NSPredicate PredicateForCompleteReminders ([NullAllowed] NSDate startDate, [NullAllowed] NSDate endDate, [NullAllowed] EKCalendar[] calendars);

		[Since (6,0)]
		[Export ("predicateForRemindersInCalendars:")]
		NSPredicate PredicateForReminders ([NullAllowed] EKCalendar[] calendars);

		[NoWatch]
		[Since (6,0)]
		[Export ("removeReminder:commit:error:")]
		bool RemoveReminder (EKReminder reminder, bool commit, out NSError error);

		[NoWatch]
		[Since (6,0)]
		[Export ("saveReminder:commit:error:")]
		bool SaveReminder (EKReminder reminder, bool commit, out NSError error);

#if MONOMAC
		[Export ("initWithAccessToEntityTypes:")]
		IntPtr Constructor (EKEntityMask accessToEntityTypes);

		[Mac (10,11)]
		[Export ("delegateSources")]
		EKSource[] DelegateSources { get; }
#endif
		[Since (6,0)]
		[Mac (10,9)]
		[Export ("requestAccessToEntityType:completion:")]
		[Async]
		void RequestAccess (EKEntityType entityType, Action<bool, NSError> completionHandler);

		[Since (6,0)]
		[Mac (10,9)]
		[Static]
		[Export ("authorizationStatusForEntityType:")]
		EKAuthorizationStatus GetAuthorizationStatus (EKEntityType entityType);
	}

	delegate void EKEventSearchCallback (EKEvent theEvent, ref bool stop);

	[Since (6,0)]
	[Mac (10,8, onlyOn64: true)]
	[BaseType (typeof (EKCalendarItem))]
	interface EKReminder {
		[Export ("startDateComponents", ArgumentSemantic.Copy)]
		[NullAllowed]
		NSDateComponents StartDateComponents { get; set; }

		[Export ("dueDateComponents", ArgumentSemantic.Copy)]
		[NullAllowed]
		NSDateComponents DueDateComponents { get; set; }

		[Export ("completed")]
		bool Completed { [Bind ("isCompleted")] get; set; }

		[Export ("completionDate", ArgumentSemantic.Copy)]
		[NullAllowed]
		NSDate CompletionDate { get; set; }

		[Export ("priority")]
		[Mac (10,9)]
		nint Priority { get; set; }
		// note: changed to NUInteger in Xcode 7 SDK

		[Export ("reminderWithEventStore:")]
		[Static]
		EKReminder Create (EKEventStore eventStore);	
	}
}